int main(int argc, char *argv[])
{
clock_t start, end, elapsed;
FILE *entrada, *entrada2, *copia, *consulta, *saida;
Words *words=NULL, *aux=NULL;
char linha[1024],linha2[1024];
char delimiters[] = " .,;:!?'\n'-*";
char *token=NULL, *cp, c, n,aspas=(char)39,tab=(char)9;
int i=0, ok=0,okay=0;
if (argc != 5) //numero de parametros corretos
{
printf("Numero incorreto de parametros.\n Sintaxe: copia arq_origem arq_destino\n");
return 1;
}
entrada = fopen(argv[1], "r"); //abre o primeiro arquivo (arquivo de entrada)
copia = fopen("facil.txt", "w"); //arquivo auxiliar
consulta = fopen(argv[2], "r"); //abre o arquivo de consulta
saida = fopen (argv[3], "w"); //abre ou cria ou arquivo de saida
if(!entrada) //caso arquivos não existam
{
printf("ERRO\n");
return 1;
}
if(!consulta)
{
printf("ERRO\n");
return 1;
}
while(!feof(entrada)) //cria arquivo auxiliar a ser usado sem pontos, e caracteres separadores especiais
{
c=fgetc(entrada);
if((c==',')||(c==':')||(c==';')||(c=='.')||(c=='-')||(c==EOF)||(c=='!')||(c=='?')||(c=='"')||(c=='*')||(c==aspas)||(c=='(')||(c==')')||(c=='_') || c==tab)
c=' ';
fputc(tolower(c),copia);
}
fclose(entrada);
fclose(copia);
entrada = fopen("facil.txt", "r");
entrada2 = fopen("facil.txt", "r");
if(!entrada)
printf("ERRO\n");
///AQUI COLOCA OS ELEMENTOS NA ABP
else
{
while(fgets(linha,1024, entrada))
{
stolower(linha); //função que transforma tudo para minusculo
cp = strdup(linha);
token = strtok (cp, delimiters); //pega tokens (usa cp como auxiliar para caso o ponteiro fique iinvalido em algum momento)
while(token!=NULL)
{
words = abp(words,token); //insere na abp
token = strtok (NULL, delimiters); //pega proximo token
}
}
}
words = abp(words, "(NULL)"); //insere a palavra "(NULL)" na abp, para ser apontada pela ultima palavra do texto
aux = words; //ponteiro aux fixo no inicio da ABP
fseek(entrada, 0, SEEK_SET);
n=fscanf(entrada2,"%s",linha2);//inicia o arquivo auxiliar uma palavra na frente
///AQUI COLOCA OS ELEMTTOS NO CAMPO LISTA DO NÓ DA ABP
while(n != EOF)
{
words = aux;
n=fscanf(entrada2,"%s",linha2);
c=fscanf(entrada,"%s",linha);
if(n == EOF)
{
words=busca(words,linha); //caso seja a ultima palavra do texto, busca ela na árvore
words->vizinhos=insere_lista(words->vizinhos,"(NULL)"); //insere ela apontando também para ("NULL")
break;
}
words=busca(words,linha); //busca a palavra no texto
words->vizinhos=insere_lista(words->vizinhos,linha2); //insere ela apontando para sua sucessora
}
// printf("iuti");
fclose(entrada2);
fclose(entrada);
moda(aux,aux); //calcula a medida estatística para cada elemento da lista
ordena(aux); //ordena a lista pelo valor de sua "moda"
///AQUI FAZ A BUSCA E GERA SAIDA
start=clock();
fseek(consulta,0,SEEK_SET);
while(fgets(linha,1023,consulta))
{
words=aux; //volta para o inicio da árvore
strcpy(linha, strtok(linha,delimiters)); //paga pegar a linha correta
words=busca(words,linha); //vai para o lugar da arvore daquela palavra
if(words!=NULL)
{
fputs("Consulta: ", saida);
fputs(words->id, saida);
fputs("\n", saida);
i=0;
while(words->vizinhos!=NULL && i<atoi(argv[4]))
{
fprintf(saida,"Sugestao: %s",words->vizinhos->id); //printa tudo bonitinho
okay=strlen(words->vizinhos->id);
for(ok=0; ok<30-okay; ok++)
fprintf(saida," ");
fprintf(saida,"(%lf)\n",words->vizinhos->moda);
words->vizinhos = words->vizinhos->prox;
i++;
}
fputs("\n", saida);
}
}
fputs("\n", saida);
end=clock(); //lê o tempo final
elapsed = 1000 * (end - start) / (CLOCKS_PER_SEC);
fprintf(saida,"Gasto: %ld ms", elapsed); //mostra o tempo final em ms
fclose(consulta);
fclose(saida);
//Desenha(aux,1);
deltree(aux);
return 0;
}
static lista arestas( grafo g ) {
lista la = constroi_lista();
if( !g ) return la;
for( no nv = primeiro_no(g->vertices); nv; nv = proximo_no(nv) ){
vertice v = conteudo(nv);
for( no na = primeiro_no(v->arestas_saida); na; na = proximo_no(na) ){
aresta a = conteudo(na);
if( !busca_aresta(la, a->origem, a->destino) )
insere_lista( a, la );
}
if( g->direcionado ) {
for( no na = primeiro_no(v->arestas_entrada); na; na = proximo_no(na) ){
aresta a = conteudo(na);
if( !busca_aresta(la, a->origem, a->destino) )
insere_lista( a, la );
}
}
}
return la;
}
void Faz_Reserva(List_head lista, List_head lista_pre) {
int option ;
cliente dados_cliente ;
printf("Insira o nome: \n ") ;
fgets(dados_cliente.nome,150, stdin);
//gets(dados_cliente.nome) ;
// getchar() ;
fflush(NULL) ;
printf("Insira agora o horario pretendido: \n " ) ;
printf("Dia: ") ;
scanf("%d", &dados_cliente.D.dia) ;
printf("Mes: ") ;
scanf("%d", &dados_cliente.D.mes) ;
printf("Hora: ") ;
scanf("%d", &dados_cliente.D.horas) ;
printf("Minuto (tenha em atençao ás meias horas: ") ;
scanf("%d", &dados_cliente.D.min) ,
do{
printf("Deseja reservar: \n") ;
printf("\t1-Lavagem \n") ;
printf("\t2-Manutencao \n") ;
printf("\t3-Sair") ;
scanf("%d",&option) ;
if(option==1) {
dados_cliente.tipo_reserva = 2 ;
// printf(" Sera que a lista existe? %d", procura_lista_data(lista,dados_cliente,0)) ; //teste
if(procura_lista_data(lista, dados_cliente,0)== 0) {
insere_lista(lista,dados_cliente) ;
imprime_lista(lista) ;
}
else {
printf("A hora escolhida nao esta disponivel. Podera fazer um pre reserva atraves do Menu se desejar.") ;
}
return ;
}
else {
dados_cliente.tipo_reserva = 1 ;
//elimina_lista(lista,dados_cliente);
// printf(" Sera que a lista existe? %d", procura_lista_data(lista,dados_cliente,0)) ; //teste
if(procura_lista_data(lista, dados_cliente,0)== 0) {
insere_lista(lista,dados_cliente) ;
imprime_lista(lista) ;
}
else {
printf("A hora escolhida nao esta disponivel. Podera fazer um pre reserva atraves do Menu se desejar.") ;
}
return ;
}
}while(option != 3) ;
return ;
}
grafo copia_grafo(grafo g) {
struct grafo *ng = malloc(sizeof(struct grafo));
if( !ng ) return NULL;
vertice v;
no nv, na;
ng->nome = malloc(sizeof(char) * strlen(nome_grafo(g)+1));
strcpy(ng->nome, g->nome);
ng->vertices = constroi_lista();
for( nv = primeiro_no(g->vertices); nv; nv = proximo_no(nv) ){
vertice vt = malloc(sizeof(struct vertice));
v = conteudo(nv);
vt->nome = malloc(sizeof(char) * strlen(nome_vertice(v))+1);
strcpy(vt->nome, nome_vertice(v));
vt->visitado = v->visitado;
vt->coberto = v->coberto;
vt->arestas_saida = constroi_lista();
vt->arestas_entrada = constroi_lista();
insere_lista(vt, ng->vertices);
}
for( nv = primeiro_no(ng->vertices); nv; nv = proximo_no(nv) ){
vertice vd = conteudo(nv);
vertice vo = busca_vertice(g->vertices, nome_vertice(vd));
for( na = primeiro_no(vo->arestas_saida); na; na = proximo_no(na) ){
aresta at = copia_aresta( conteudo(na), ng );
insere_lista(at, vd->arestas_saida);
}
if( g->direcionado ){
for( na = primeiro_no(vo->arestas_entrada); na; na = proximo_no(na) ){
aresta at = copia_aresta( conteudo(na), ng );
insere_lista(at, vd->arestas_entrada);
}
}
}
ng->direcionado = g->direcionado;
ng->ponderado = g->ponderado;
ng->n_vertices = g->n_vertices;
ng->n_arestas = g->n_arestas;
return ng;
}
lista * nova_permuta(lista *l, int *v, int k, int n)
{
int i, aux;
if (k == n - 1)
{
//mostre(v, n);
/*Insere na lista de permutacoes*/
int *tmp = (int*) malloc(sizeof(int));
for(i=0; i < n; i++)
tmp[i] = v[i];
insere_lista((void*)tmp, l);
return l;
}
else
{
l = nova_permuta(l, v, k + 1, n);
i = k + 1;
while (i < n)
{
aux = v[k]; // troca
v[k] = v[i];
v[i] = aux;
/* permuta segmento de k+1 ate n e retorna com
o segmento restaurado, isto e, da forma como
foi passado para a funcao */
l = nova_permuta(l, v, k + 1, n);
aux = v[k]; // restuara
v[k] = v[i];
v[i] = aux;
i = i + 1;
}
}
return l;
}
//------------------------------------------------------------------------------
static void guarda_arcos(Agraph_t *g, Agnode_t *v) {
for (Agedge_t *a=agfstout(g,v); a; a=agnxtout(g,a))
if ( ! busca_aresta(a) )
insere_lista(a, lista_arestas);
}
static lista vizinhanca_entrada(vertice v){
lista viz = constroi_lista();
for (no n=primeiro_no(v->adjacencias_entrada); n!=NULL; n=proximo_no(n)) {
adjacencia a = conteudo(n);
insere_lista(a->v_origem, viz);
}
return viz;
}
void insere(Hash* h, char* chave, void* estrutura) {
int valor = hash(h, chave);
printf("Inserindo um novo valor na tabela Hash ( chave: %s ):\n\tValor da hash: %d\n", chave, valor);
if(h->tabela[valor] != NULL) {
printf("\tColisao ao inserir, chave %d\n", valor);
} else {
h->tabela[valor] = inicializa_lista();
}
h->tabela[valor] = insere_lista(h->tabela[valor], estrutura);
}
static void cria_vizinhanca(grafo g, vertice origem, vertice destino, long int peso){
adjacencia viz_1 = malloc(sizeof(struct adjacencia));
if(viz_1 == NULL)
printf("Sem memoria");
else{
viz_1->peso = peso;
viz_1->v_origem = origem;
viz_1->v_destino = destino;
insere_lista(viz_1, origem->adjacencias_saida);
origem->grau_saida++;
destino->grau_entrada++;
if (!direcionado(g)) {
// se o grafo não for direcionado, a aresta deve aparecer também na
// lista de adjacencia do vertice dest
adjacencia viz_2 = malloc(sizeof(struct adjacencia));
if(viz_2 == NULL)
printf("Sem memoria");
else{
viz_2->peso = peso;
viz_2->v_origem = destino;
viz_2->v_destino = origem;
insere_lista(viz_2, destino->adjacencias_saida);
destino->grau_saida++;
origem->grau_entrada++;
}
}
else{
adjacencia viz_3 = malloc(sizeof(struct adjacencia));
if(viz_3 == NULL)
printf("Sem memoria");
else{
viz_3->peso = peso;
viz_3->v_origem = origem;
viz_3->v_destino = destino;
insere_lista(viz_3, destino->adjacencias_entrada);
}
}
}
g->n_arestas++;
}
static lista vizinhanca_saida(vertice v){
lista viz = constroi_lista();
for (no n=primeiro_no(v->adjacencias_saida); n!=NULL; n=proximo_no(n)) {
if(n != NULL){
adjacencia a = conteudo(n);
insere_lista(a->v_destino, viz);
}
}
return viz;
}
//------------------------------------------------------------------------------
//
static grafo grafo_emparelhamento(grafo g) {
grafo e = malloc(sizeof(struct grafo));
if( !e ) return NULL;
e->nome = malloc(sizeof(char) * strlen(g->nome)+1);
strcpy(e->nome, g->nome);
e->direcionado = g->direcionado;
e->ponderado = g->ponderado;
e->vertices = constroi_lista();
for( no nv = primeiro_no(g->vertices); nv; nv = proximo_no(nv) ){
vertice ve = malloc(sizeof(struct vertice));
vertice vg = conteudo(nv);
ve->nome = malloc(sizeof(char) * strlen(nome_vertice(vg))+1);
strcpy(ve->nome, nome_vertice(vg));
ve->visitado = 0;
ve->coberto = vg->coberto;
ve->arestas_saida = constroi_lista();
ve->arestas_entrada = constroi_lista();
insere_lista(ve, e->vertices);
}
e->n_vertices = tamanho_lista(e->vertices);
e->n_arestas = 0;
for( no nv = primeiro_no(e->vertices); nv; nv = proximo_no(nv) ){
vertice ve = conteudo(nv);
vertice vg = busca_vertice(g->vertices, nome_vertice(ve));
for( no na = primeiro_no(vg->arestas_saida); na; na = proximo_no(na) ){
aresta ag = conteudo(na);
if (ag->origem != vg) continue;
if( ag->coberta ){
aresta ae = copia_aresta( ag, e );
insere_lista(ae, ae->destino->arestas_saida);
insere_lista(ae, ae->origem->arestas_saida);
e->n_arestas++;
}
}
}
return e;
}
lista vizinhanca(vertice v, int direcao, grafo g) {
lista la, lv = constroi_lista();
if( !v || !g ) return lv;
switch( direcao ){
case 0 : la = v->arestas_saida; break;
case 1 : la = v->arestas_saida; break;
case -1 : la = v->arestas_entrada; break;
}
for( no n = primeiro_no(la); n; n = proximo_no(n) ){
aresta a = conteudo(n);
if( v == a->origem ){
insere_lista( a->destino, lv );
}
if( v == a->destino ){
insere_lista( a->origem, lv );
}
}
return lv;
}
/* função principal do programa */
int main (int argc, char *argv[]){
char *texto, opcao; /* crio uma string para armazenar cada palavra do texto */
node *head; /* crio um apontador para marcar o começo da lista */
int qtd_impressos = 0, sensitive = 0;
/* laço que verifica se há algum parâmetro enviado na chamada do programa */
while((opcao = getopt(argc, argv, "n:I")) != -1){
switch(opcao){
case 'I': /* caso o insensitive case for ativado */
sensitive = 1;
break;
case 'n': /* caso há um limite nas impressões */
qtd_impressos = atoi(optarg);
break;
}
}
texto = malloc (20 * sizeof(char)); /* aloco espaço para o texto */
head = malloc (sizeof(node)); /* aloco espaço para o node */
head->qtd = 0; /* inicializo o valor da variável com 0 */
head->next = NULL; /* o next do node aponta para o nulo */
printf("\n\tEXERCICIO PROGRAMA 1 - MAC0323 ESTRUTURA DE DADOS\n\n\n");
/* loop que lerá uma palavra por vez */
while (scanf("%s", texto) != EOF){
verifica_palavra(texto, sensitive); /* faço a verificação da pontuação */
insere_lista(texto, head); /* insiro na lista */
}
head->next = lmergesort_alfabetica(head->next); /* faço o primeiro mergesort para ordenar em ordem alfabética */
contabiliza_strings(head); /* faço a contagem das strings */
head->next = lmergesort_numerico(head->next); /* faço o segundo mergesort para ordenar em ordem numérica */
imprime_lista(head, qtd_impressos); /*imprimo a lista final */
libera_lista(head);/* libero a lista */
/* libero a minha célula usada como cabeça */
free(head);
return 0;
}
//------------------------------------------------------------------------------
//
static int busca_caminho(vertice v, lista l, int last) {
// essa função é chamada pela função que tenta achar um caminho aumentante
// pra cada vértice não coberto (e retorna assim que achar)
// e last é inicialmente 1, pois a primeira aresta será 0 (não coberta)
if ( !v->coberto && !v->visitado ) {
return 1; // true
}
v->visitado = 1;
lista la = v->arestas_saida;
for( no n = primeiro_no(la); n; n = proximo_no(n) ){
aresta a = conteudo(n);
if (a->coberta == last) continue;
vertice outro = a->origem == v ? a->destino : a->origem;
if (!outro->visitado && busca_caminho(outro, l, !last)) {
insere_lista(a, l);
return 1; // true
}
}
return 0; //false
}
grafo le_grafo(FILE *input) {
Agraph_t *ag = agread(input, 0);
if(!(ag && agisstrict(ag)))
return NULL;
// struct grafo *g = malloc(sizeof(struct grafo));
grafo g = malloc(sizeof(struct grafo));
if( !g ) return NULL;
g->vertices = constroi_lista();
g->nome = malloc(sizeof(char) * strlen(agnameof(ag)+1));
strcpy(g->nome, agnameof(ag));
g->direcionado = agisdirected(ag);
g->n_vertices = (unsigned int)agnnodes(ag);
g->n_arestas = (unsigned int)agnedges(ag);
g->ponderado = 0;
for( Agnode_t *v = agfstnode(ag); v; v = agnxtnode(ag,v) ){
vertice vt = malloc(sizeof(struct vertice));
vt->nome = malloc(sizeof(char) * strlen(agnameof(v))+1);
strcpy( vt->nome, agnameof(v) );
vt->visitado = 0;
vt->coberto = 0;
vt->arestas_saida = constroi_lista();
vt->arestas_entrada = constroi_lista();
insere_lista(vt, g->vertices);
}
for( Agnode_t *v = agfstnode(ag); v; v = agnxtnode(ag,v) ){
vertice vt = busca_vertice(g->vertices, agnameof(v));
if( g-> direcionado ){
for( Agedge_t *e = agfstout(ag,v); e; e = agnxtout(ag,e) ){
aresta at = cria_aresta(g->vertices, e);
if( at->peso != 0 ) g->ponderado = 1;
insere_lista(at, vt->arestas_saida);
}
for( Agedge_t *e = agfstin(ag,v); e; e = agnxtin(ag,e) ){
aresta at = cria_aresta(g->vertices, e);
if( at->peso != 0 ) g->ponderado = 1;
insere_lista(at, vt->arestas_entrada);
}
}
else {
for( Agedge_t *e = agfstedge(ag,v); e; e = agnxtedge(ag,e,v) ){
if( agtail(e) != v ) continue;
aresta at = cria_aresta(g->vertices, e);
if( at->peso != 0 ) g->ponderado = 1;
insere_lista(at, at->origem->arestas_saida);
insere_lista(at, at->destino->arestas_saida);
}
}
}
if( agclose(ag) )
return NULL;
return g;
}
/* PROGRAMA QUE VERIFICA A FILA DE MSGS, E TRATA A REQUISICAO!*/
int main(){
t_processo *cabeca = NULL;
t_processo *aux;
t_msg msgrecebida;
std::time_t tempoCorrente;
struct tm * tempoInfo;
int key_msg;
int tamanhoLista;
int ppid; // Parent Process ID
signal(SIGALRM,dummy); //ROTINA DE SIGNAL_ALRM
key_msg = msgget(10,0x1FF); //CRIAR FILA DE MSG
while(1){
while(msgrcv(key_msg,&msgrecebida,size_msg,0,IPC_NOWAIT) > 0){ //LOOP DE RECEBER MENSAGENS E INSERIR NA FILA PROCESSSOS
insere_lista(&cabeca,&msgrecebida);
}
aux = cabeca;
tamanhoLista = 0;
while(aux != NULL){
time(&tempoCorrente);
// tempoInfo = localtime(&tempoCorrente); //PEGA O TEMPO ATUAL DE FORMA SEPARADA
if( aux->minstamp == (unsigned) ((tempoInfo->tm_hour*60) + tempoInfo->tm_min) && aux->vezes > 0 ){
printf("\n\tHORA DE EXECUTAR UM PROCESSO!\n");
ppid = fork();
k
printf("\n\tppid = %d \n",pid);
if(ppid == 0){
if(execl(aux->msg,aux->msg,EComercial, (char*)0) < 0){
printf("\nErro no execl! \n");
exit(1);
}
}else{
aux->vezes--;
aux->minstamp = ((tempoInfo->tm_hour*60) + tempoInfo->tm_min) + aux->deltaHora*60 + aux->deltaMin ; //ATUALIZAR A PROX VEZ
aux->pid = ppid;
printf("\n\telse aux->pid = %u \n",aux->pid);
}
}
tamanhoLista++;
aux = aux->prox;
printf("\n\twhile(aux != NULL)FINAL\n");
}
printf("\n\tSAI DO LOOP DE EXEC\n");
imprimeLista(&cabeca);
int i ;
aux = cabeca;
if(aux != NULL){
for( i = 0; i < tamanhoLista - 1; i++){
printf("\n\tProcesso\t%d\t deltaHora %u:%u x %u\t minstamp\t%u\tprox\t=%p\n"
,aux->pid
,aux->deltaHora
,aux->deltaMin
,aux->vezes
,aux->minstamp
,aux->prox);
if(aux->vezes > 0 ){
kill(aux->pid,SIGSTOP);
kill(aux->prox->pid,SIGCONT);
alarm(3);
}
if(aux->prox != NULL)
aux = aux->prox;
}
kill(aux->pid,SIGSTOP);
kill(cabeca->pid,SIGCONT);
}
}
return 0 ;
}
