int leer (DiccionarioConsecutivo * x, char * nombre)
{
long i;
long longitud;
char ciudad [MAX];
long distancia;
FILE * p = fopen (nombre, "rb");
if (!p)
return 1;
fread (&(x->maximo), sizeof (long), 1, p);
iniciar (x, x->maximo);
for (i=0; i<x->maximo; i++)
{
fread (&longitud, sizeof (long), 1, p);
fread (ciudad, sizeof (char), longitud, p);
ciudad[longitud] = '\0';
fread (&distancia, sizeof (long), 1, p);
insertar (x, ciudad, distancia);
}
fclose (p);
return 0;
}
main()
{
int opcao;
iniciar(matriz);
do
{
menu();
printf("\n Qual a sua opção");
scanf("%d",&opcao);
system("CLS");
switch(opcao)
{
case 1:
//insere_jogador();
//mostrar_tabuleiro(matriz);
//insere_submarino();
//insere_2canos();
//insere_3canos();
//insere_4canos();
insere_portavioes();
//joga();
break;
case 2:
break;
}
}while(opcao!=0);
}
void pruebasEstaLleno(){
tablero t;
int i,j;
//Iniciamos un tablero y lo mostramos en el entorno
iniciar(t,TAMANIOTABLERO);
entornoIniciar(TAMANIOTABLERO);
//Ahora recorreremos la matriz del tablero asignandole valores a las casillas
//y luego comprobaremos si el módulo que se encarga de ver si está lleno funciona
for(i=0;i<TAMANIOTABLERO;i++){
for(j=0;j<TAMANIOTABLERO;j++){
t.m[i][j]=2;
}
}
pintarTablero(t);//Pintamos el tablero para mostrar los cambios en pantalla
entornoPausa(5000000);
if(EstaLleno(t)==true){
cout<<"El modulo detecta que todas las casillas estan llenas y finaliza el juego"<<endl;
cout<<" "<<endl;
cout<<"El módulo da el resultado esperado"<<endl;
}
else{
cout<<"Error en el módulo para comprobar si está lleno"<<endl;
}
}
void pruebasDesplazarIzd(){
tablero t;
long long int puntuacion=0;
iniciar(t,TAMANIOTABLERO);
entornoIniciar(TAMANIOTABLERO);
//generamos unos valores iniciales en cualquier casilla
t.m[1][1]=2;
t.m[1][2]=2;
pintarTablero(t);//mostramos los cambios en la pantalla
entornoPausa(2000000);
desplazarIzd(t,puntuacion);//Accedemos al módulo
pintarTablero(t);
entornoPausa(2000000);
if(t.m[1][0]==4){
//Como sabemos que si el módulo funcionase debería desplazar y sumar los numeros
//que hemos puesto,comprobamos que la casilla en la que teóricamente queda el resultado
//tiene el valor esperado
cout<<"Veremos como los valores se desplazan a la izquierda"<<endl;
cout<<"El modulo funciona"<<endl;
}
else{
cout<<"Fallo en el módulo de desplazar izquierda"<<endl;
}
}
void main()
{
struct nodo *cab;
int cliente;
void iniciar (struct nodo **p);
void sumar (struct nodo **p,int objeto);
void atender (struct nodo **p,int *s);
void atender_1 (struct nodo **p,int *s);
void listar (struct nodo *p);
iniciar (&cab);
sumar (&cab,'A');
sumar (&cab,'B');
atender (&cab,&cliente);
p1 (cliente);
sumar (&cab,'C');
sumar (&cab,'D');
sumar (&cab,'E');
atender (&cab,&cliente);
p1 (cliente);
atender (&cab,&cliente);
p1 (cliente);
sumar (&cab,'F');
atender (&cab,&cliente);
p1 (cliente);
atender (&cab,&cliente);
p1 (cliente);
listar (cab);
}
int main()
{
iniciar();
ler();
imprime();
return 0;
}
void pruebasIniciar(){
tablero t;//Declaramos una variable tipo tablero la cual iniciar
iniciar(t,TAMANIOTABLERO);
//Iniciamos el tablero t con el tamaño deseado,para esta prueba será un número entero
entornoIniciar(TAMANIOTABLERO);
entornoPausa(2000000);
//Mostramos el tablero iniciado en el entorno gráfico durante unos segundos
cout<<"Se mostrará el tablero con todas las casillas vacias"<<endl;
}
void pruebasGenerar(){
//La prueba de este módulo es similar a la del anterior
tablero t;//Iniciamos un tablero t
iniciar(t,TAMANIOTABLERO);
entornoIniciar(TAMANIOTABLERO);
generar(t);//Generamos un valor en el tablero
pintarTablero(t);//Mostramos los cambios en pantalla durante unos segundos
entornoPausa(5000000);
cout<<"Se genrará 1 numero aleatorio (2 o 4) en una casilla aleatoria vacia del tablero"<<endl;
}
int main(int argc, char *argv[]){
iniciar(argc, argv);
Token *token = proximo_token();
/*while(token != NULL){
imprimir_token(token);
token = proximo_token();
}*/
encerrar();
return 0;
}
int main(int argc, char **argv)
{
char buffer[10];
mqd_t cola;
struct mq_attr attr = {
.mq_flags = 0, /* Message queue flags. */
.mq_maxmsg = 10, /* Maximum number of messages. */
.mq_msgsize = 10, /* Maximum message size. */
.mq_curmsgs = 0, /* Number of messages currently queued. */
};
cola = mq_open("/mq_a",
O_CREAT | O_RDWR, 0600, &attr);
if (cola < 0) {
perror("mq_open");
return -1;
}
printf("La cola devolvio: %d", cola);
TMensaje m;
int count = 10;
srand(getpid());
iniciar(argc, argv, &m);
strcpy(m.imagen, "pelota.png");
m.x = rand() % 800;
m.y = rand() % 540;
printf("%d %d\n", m.x, m.y);
m.x += 1;
m.y = 1;
m.pid = getpid();
enviar(&m);
mq_receive(cola,
(char*) &buffer, attr.mq_msgsize, NULL);
printf("No debería seguir!");
while(count-- > 0)
{
// Enviar el mensaje
m.x += 1;
m.y = 1;
m.pid = getpid();
enviar(&m);
usleep(500000);
if ( count == 5) {
strcpy(m.imagen, "pantera.png");
}
}
return 0;
}
void pruebasGenerar_inicial(){
tablero t;//Iniciamos un tablero t
int numiniciar=2;
iniciar(t,TAMANIOTABLERO);
entornoIniciar(TAMANIOTABLERO);
generar_inicial(t,numiniciar);//Generamos dos valores iniciales en un lugar aleatorio del tablero
pintarTablero(t);//Mostramos los cambios en pantalla durante unos segundos
entornoPausa(5000000);
//Se podrá comprobar que el módulo es correcto de manera visual si se generan 2 valores
//en algún lugar del tablero que sea 2 ó 4
cout<<"Se generarán 2 números (2 o 4)aleatorios en cualquier casilla del tablero"<<endl;
}
int main(int argc, char *argv[]){
int opt= 0;
/* 0 = false
1 = true */
int on = 0;
int help = 0;
int cantidadDeMensajes;
char *numero;
//struct para las opciones que existen
static struct option long_options[] = {
{"on", required_argument, 0, 'o' },
{"help", no_argument, 0, 'h' },
{0, 0, 0, 0 }
};
int long_index =0;
//captura de las posibles respuestas
while ((opt = getopt_long_only(argc, argv,"", long_options, &long_index )) != -1) {
switch (opt) {
case 'o' :
on = 1;
numero = optarg;
cantidadDeMensajes = atoi(numero);
break;
case 'h' :
help = 1;
break;
default:
instrucciones();
exit(EXIT_FAILURE);
break;
}
}
printf("on : %d\n",opt);
if (on == 1) {
if(cantidadDeMensajes==0)
printf("no se puede inicializar con 0 mensajes, por favor elija otra cantidad\n");
else
printf("Se desea enviar: %i mensajes\n", cantidadDeMensajes);
iniciar(cantidadDeMensajes);
}
if (help == 1){
instrucciones();
exit(EXIT_FAILURE);
}
return 0;
}
void Investigador::iniciarRecorrido() {
ParserConfiguracion parser;
int puerta;
string numeroPuerta;
LOG("INVESTIGADOR %d: INICIANDO RECORRIDO", getpid());
parser.cargarConfiguracion(configuracion);
srand(time(NULL));
puerta = (rand() % Utils::string2int(parser.getValor("puertas"))) + 1;
numeroPuerta = Utils::int2String(puerta);
LOG("INVESTIGADOR %d: PUERTA DE ENTRADA Y DE SALIDA: %d", getpid(), puerta);
iniciar(tipoInvest, puerta, puerta);
LOG("INVESTIGADOR %d: TERMINANDO RECORRIDO", getpid());
}
void pruebasVacia(){
tablero t;
iniciar(t,TAMANIOTABLERO);
//Ahora vamos a asignarle un valor cualquiera a una casilla del tablero
t.m[2][2]=4;
//Para hacer la comprobación del módulo esperaremos que el resultado dado sea false al
//checkear la casilla
if(vacia(t,2,2)==false){
cout<<"El módulo funciona de manera correcta"<<endl;
}
else{
cout<<"El módulo para comprobar si la casilla está vacía no funciona"<<endl;
}
}
void dataFile::searchAVL(char *protocolo, QTableWidget *tb)
{
disco.open(name.toStdString().c_str(),ios::binary | ios::in | ios::out);
//Inicio de timer para buscar por protocolo
iniciar();
QList<long> *list=arbolAVL->mostrarLista(protocolo);
detener();
this->timeSearchAvl += this->getMS();
//Termina
search(protocolo,list,tb);
disco.close();
}
void pruebasObtenerValor(){
tablero t;
iniciar(t,TAMANIOTABLERO);
//Damos un valor a cualquier casilla
t.m[0][0]=5;
if(obtenerValor(t,0,0)==5){
//Comprobamos si el módulo devuelve el valor que hemos asignado a la casilla
cout<<"Asignamos el valor 5 a la casilla (0,0)"<<endl;
cout<<"El valor obtenido de la casilla (0,0) es: "<<obtenerValor(t,0,0)<<endl;
cout<<"EL módulo es correcto"<<endl;
}
else{
cout<<"Error en el módulo de obtener valor"<<endl;
}
}
void dataFile::searchHashDestino(char *destino, QTableWidget *tb)
{
disco.open(name.toStdString().c_str(),ios::binary | ios::in | ios::out);
//Inicio de timer para buscar por destino
iniciar();
QList<long> *list=hashDestino->mostrarLista(destino);
detener();
this->timeSearchHashDestino += this->getMS();
//Termina
search(destino,list,tb);
disco.close();
}
void dataFile::searchHashSource(char *source, QTableWidget *tb)
{
disco.open(name.toStdString().c_str(),ios::binary | ios::in | ios::out);
//Inicio de timer para buscar por source
iniciar();
QList<long> *list=hashSource->mostrarLista(source);
detener();
this->timeSearchHashSource += this->getMS();
//Termina
search(source,list,tb);
disco.close();
}
/*
* Ordenação usando árvore binária de busca.
*
* Neste algoritmo é usada uma árvore binária de busca,
* onde os elementos do array a ser ordenado são inseridos um
* a um. Após a inserção, a árvore é percorrida em ordem e cada
* raiz visitada é inserida de volta no array do início ao fim.
*
* Complexidade:
* Melhor caso: O(n)
* Caso médio: O(n log n)
* Pior caso: O(n log n)
*/
void binaryTreeSort( int *array, int tamanho ) {
int i;
ArvoreBinariaBusca a;
iniciar( &a );
for ( i = 0; i < tamanho; i++ ) {
inserir( &a, array[i] );
}
int indice = 0;
percorrerEmOrdemInserindo( a.raiz, array, &indice );
esvaziar( &a );
}
telaDePerguntas::telaDePerguntas(QWidget *parent, int tipo, int qtdq) :
QDialog(parent),
ui(new Ui::telaDePerguntas)
{
std::cout << "tela de quiz instanciado" <<std::endl;
ui->setupUi(this);
//garante pelo menos uma pergunta no quiz
if(qtdq == 0)
qtdq = 1;
//instancia um objeto
q = new quiz(tipo, qtdq);
resposta = 4;
pontuacaoDoQuiz = 0;
questaoAtual = 0;
iniciar();
}
Ebackup::Ebackup( QWidget* parent )
: EVentana( parent ), Ui_FormBackupBase()
{
setupUi(this);
this->setAttribute( Qt::WA_DeleteOnClose );
setObjectName( "backup" );
setWindowTitle( "Copia de Seguridad" );
setWindowIcon( QIcon( ":/imagenes/backup.png" ) );
PBProgreso->setValue( 0 );
LDebug->setText( "Presione Iniciar para comenzar" );
// inicializo el deposito de datos
datos = new QByteArray();
comprimidos = new QByteArray();
ActCerrar = new QAction( "Cerrar", this );
ActCerrar->setStatusTip( "Cierra la ventana y cancela cualquier backup que se este realizando" );
ActCerrar->setIcon( QIcon( ":/imagenes/fileclose.png" ) );
connect( ActCerrar, SIGNAL( triggered() ), this, SLOT( close() ) );
ActIniciar = new QAction( "Iniciar", this );
ActIniciar->setStatusTip( "Inincia la generación de los backups" );
ActIniciar->setIcon( QIcon( ":/imagenes/next.png" ) );
connect( ActIniciar, SIGNAL( triggered() ), this, SLOT( iniciar() ) );
ActDetener = new QAction( "Detener", this );
ActDetener->setStatusTip( "Detiene la ejecución actual del backup" );
ActDetener->setIcon( QIcon( ":/imagenes/stop.png" ) );
connect( ActIniciar, SIGNAL( triggered() ), this, SLOT( detener() ) );
connect( this, SIGNAL( cambiarDetener( bool ) ), ActDetener, SLOT( setEnabled( bool ) ) );
emit cambiarDetener( false );
addAction( ActIniciar );
addAction( ActDetener );
addAction( ActCerrar );
ChBBaseDatos->setCheckState( Qt::Checked );
connect( tBBuscar, SIGNAL( clicked() ), this, SLOT( abrirArchivoBackup() ) );
Pestanas->setTabIcon( 0, QIcon( ":/imagenes/backup1.png" ) );
Pestanas->setTabIcon( 1, QIcon( ":/imagenes/backup2.png" ) );
Pestanas->widget( 0 )->setObjectName( "crearBackup" );
Pestanas->widget( 1 )->setObjectName( "restaurarBackup" );
Pestanas->setCurrentIndex(0);
}
void pruebasQueTamanio(){
//La prueba de este módulo es muy simple,iniciaremos un tablero de tamaño TAMANIOTABLERO
//posteriormente haremos una llamada al módulo y esperaremos que devuelva el valor de la
//constante TAMANIOTABLERO
tablero t;
iniciar(t,TAMANIOTABLERO);
if(quetamanio(t)==TAMANIOTABLERO){
//Mostraremos un mensaje en la consola con el resultado de la comprobación
cout<<"El tamaño del tablero es: "<<TAMANIOTABLERO <<endl;
cout<<""<<endl;
cout<<"El módulo funciona como se espera"<<endl;
}
else{
cout<<"Error en el módulo que comprueba el tamaño del tablero"<<endl;
}
}
int main(void){
fila fila1;
int iTamanho=10;
iniciar(iTamanho,&fila1);
for(int cont = 0 ; cont < 10;cont++)
push(cont,&fila1);
int itens=0;
listar(fila1,&itens);
for(int cont=fila1.inicio;cont<fila1.fim;cont++){
printf("%d\n",fila1.elementos[cont]);
printf("Quantidade de Itens:%d\n",itens);
}
for(int cont=fila1.inicio;cont<7;cont++)
pop(&fila1);
int *lista=listar(fila1,&itens);
printf("\n\n\tRemoção de Itens!\n\n");
for(int cont=fila1.inicio;cont<fila1.fim;cont++){
printf("%d\n",*lista++);
//printf("%d\n",fila1.elementos[cont]);
printf("Quantidade de Itens:%d\n",itens);
}
printf("\n\n\tRemoção de Itens!\n\n");
for(int cont = fila1.inicio;cont<fila1.fim;cont++){
lista=listar(fila1,&itens);
pop(&fila1);
printf("%d\n",*lista);
printf("Quantidade de Itens:%d\n",itens);
}
if(vazia(fila1)==true) printf("\tLista Vazia!\n");
else printf("\tLista Não Vazia!\n");
printf("\n\n\tInserindo Outras Coisas na Lista Na lista\n\n");
for(int cont = 9 ; cont >= 0;cont--)
push(cont,&fila1);
listar(fila1,&itens);
for(int cont=fila1.inicio;cont<fila1.fim;cont++){
printf("%d\n",fila1.elementos[cont]);
printf("Quantidade de Itens:%d\n",itens);
}
if(cheia(fila1)==true) printf("Lista cheia Novamente!\n");
else printf("Lista não está cheia ! \n");
printf("Teste das Músicas!\n");
for(int cont=0;cont<4;cont++)
for(int cont1=0;cont1<4;cont1++) songControl(cont,cont1);
}
int32_t hiloEjecucionCPU(t_HiloCPU* paramsCPU)
{
log_info(MemoriaLog,"Esperando pedidos de Cpu \n");
int32_t codigoOperacion;
codigoOperacion = recibirCodigoOperacion(paramsCPU->cpuSocket);
if(codigoOperacion==-1) {
log_error(MemoriaLog, RED"No se recibió correctamente el código de operación\n"RESET);
return EXIT_FAILURE;
}
while(codigoOperacion!=0) {
switch(codigoOperacion) {
case codigo_iniciar:
iniciar(paramsCPU->cpuSocket, paramsCPU->swapSocket);
break;
case codigo_finalizar:
finalizar(paramsCPU->cpuSocket, paramsCPU->swapSocket);
break;
case codigo_leer:
lectura(paramsCPU->cpuSocket, paramsCPU->swapSocket);
break;
case codigo_escribir:
escritura(paramsCPU->cpuSocket, paramsCPU->swapSocket);
break;
}
codigoOperacion = recibirCodigoOperacion(paramsCPU->cpuSocket);
if(codigoOperacion==-1) {
log_error(MemoriaLog, RED"No se recibió correctamente el código de operación\n"RESET);
return EXIT_FAILURE;
}
}
if(codigoOperacion==0){
log_info(MemoriaLog, "Se desconectó un CPU\n");
bool PorCerrado(sock_t* socket){
return socket->fd==0;
}
int32_t veces = list_count_satisfying(CPUsConectados,(void*)PorCerrado);
int32_t it;
for(it=0; it<veces; it++){
list_remove_and_destroy_by_condition(CPUsConectados, (void*)PorCerrado, (void*)clean_socket);
}
}
void imprime_largura(Arv *raiz){
Arv* aux;
Fila fila;
iniciar(&fila);
if (raiz!=NULL){
inserir_fila(&fila, raiz);
while(fila_vazia(&fila)==0){
aux = remover_fila(&fila);
printf("%d.", aux->elem);
if(aux->esq!=NULL)
inserir_fila(&fila, aux->esq);
if(aux->dir!=NULL)
inserir_fila(&fila, aux->dir);
}
}
else
printf("Arvore vazia!\n");
}
void GL_Contexto::correr()
{
if(iniciar())
{
cargar();
DeltaTiempo=0;
while(!glfwWindowShouldClose(_ventana))
{
_frame_pasado = glfwGetTime();
glfwPollEvents();
actualizar();
renderizar();
DeltaTiempo=glfwGetTime()-_frame_pasado;
}
terminar();
glfwTerminate();
}
}
int main(){
Pilha myStack;
int *estado_atual;
unsigned int qtde;
iniciar(7, &myStack);
push(53, &myStack);
push(77, &myStack);
push(65, &myStack);
estado_atual = listar(myStack, &qtde);
for (int i = 0; i < qtde; i++)
printf("%d-", estado_atual[i]);
printf("\nRemovendo 1 elemento\n");
pop(&myStack);
free(estado_atual);
estado_atual = listar(myStack, &qtde);
for (int i = 0; i < qtde; i++)
printf("%d-", estado_atual[i]);
getchar();
return 0;
}
void pruebasPuntuacionMax(){
tablero t;//Iniciamos un tablero t para la prueba
//Declaramos la variable que nos servirá de referencia como valor máximo en la prueba
int maxPrueba=64;
iniciar(t,TAMANIOTABLERO);
entornoIniciar(TAMANIOTABLERO);//Mostramos el tablero en el entorno gráfico
t.m[0][0]=64;//Le damos a una de las casillas el valor máximo
pintarTablero(t);//Pintamos el tablero para mostrar los cambios
entornoPausa(5000000);
if(puntuacionMax(t,maxPrueba)==true){
//Si el módulo funciona tal y como se espera se mostrará un mensaje
cout<<"EL modulo finalizará al haber encontrado el valor máximo que es 64"<<endl;
cout<<" "<<endl;
cout<<"El módulo funciona correctamente"<<endl;
}
else{
//En caso contrario se mostraría un mensaje de error
cout<<"El módulo no funciona de manera correcta"<<endl;
}
}
/*****************************PRINCIPAL******************************/
int main()
{
int i;
poblacion *p;
char nombre_archivo[255];
printf("Nombre>");
scanf("%s",nombre_archivo);
/* iniciar problema*/
iniciar(nombre_archivo);
/* crea una poblacion nueva */
p = alloc_poblacion(tampoblacion,bpi);
for (i = 0; i < iter; i++)
{
imprime_poblacion(p);
printf("\n");
printf("Generacion = %i mejor hasta ahora= %i promedio hasta ahora = %i\n",i,mejor_aptitud(p),aptitud_promedio(p));
if (mejor_aptitud(p)>=numclausulas)
{
printf("\nProblema Resuelto!!!\n");
if( mejor_aptitud(p) < numclausulas)
printf("Formula con alguna Contradiccion?\n");
break;
}
else
{
evolucionar_poblacion(p,cruzamiento,mutacion);
if ( iter == MAXITERACIONES && (mejor_aptitud(p) < aptitud_optimo() ) )
printf("\nProblema Indeterminado\n");
}
}
libera_poblacion(p);
printf("\nNumero de Generaciones: %i\nTama¤o de la Poblacion %i\n",i,tampoblacion);
printf("Numero de Iteraciones: %i\nProbabilidad Cruzamiento %f\n", iter, cruzamiento);
printf("Probabilidad Mutacion %f\n",mutacion);
printf("\nNumero de variables en Archivo %i\n",numvars);
printf("Numero de clausulas en Archivo %i\n",numclausulas);
getch();
return 0;
}
int main() {
HeapMinMax heap;
iniciar( &heap );
inserir( &heap, 10 );
inserir( &heap, 4 );
inserir( &heap, 2 );
inserir( &heap, 21 );
inserir( &heap, -1 );
inserir( &heap, 3 );
printf( "Item com maior prioridade: %d\n", consultarMaiorPrioridade( &heap ) );
printf( "Item com menor prioridade: %d\n", consultarMenorPrioridade( &heap ) );
imprimir( &heap );
printf( "Removendo maior: %d\n", removerMaiorPrioridade( &heap ) );
printf( "Removendo maior: %d\n", removerMaiorPrioridade( &heap ) );
printf( "Removendo menor: %d\n", removerMenorPrioridade( &heap ) );
printf( "Removendo menor: %d\n", removerMenorPrioridade( &heap ) );
imprimir( &heap );
esvaziar( &heap );
inserir( &heap, 2 );
inserir( &heap, 21 );
inserir( &heap, -1 );
imprimir( &heap );
printf( "Removendo maior: %d\n", removerMaiorPrioridade( &heap ) );
imprimir( &heap );
return 0;
}
