void VentanaPrincipal::open()
{
QString fileName = QFileDialog::getOpenFileName(this,
tr("Open model"), ".",
tr("simplicial complex files(*.sp)"));
if (!fileName.isEmpty())
leerArchivo(fileName);
}
NodoInt* vender(char dep[15], NodoInt *lista)
{
lista=leerArchivo(dep,lista);
int v,c; //v= valor c=cantidad
int venta,cuantos,tmp,total;
char nom[15]; //guardara el nombre del producto
printf("Selecciona el producto que deseas vender\n");
imprime_productos_precio(lista);
scanf("%d",&venta);
if (venta<1)
{
printf("Error\n");
}
else
{
venta = venta-1;
v=listaInt_obtenerV(lista,venta);
c=listaInt_obtenerC(lista,venta);
strcpy(nom,(listaInt_obtenerP(lista,venta,nom)));
printf("¿Cuantos productos deseas vender?\n");
scanf("%d",&cuantos);
if(c<cuantos)
{
printf("Lo sentimos no contamos con esa cantidad de productos\n Contamos con : %d\n",c);
}
else
{
listaInt_imprimir(lista);
printf("El nombre del producto :%s\n",nom);
printf("El producto cuesta :%d\n",v);
printf("Tenemos disponibles %d productos\n",c);
tmp=c-cuantos;
total=v*cuantos;
printf("Su venta total es de %d pesos\n",total);
printf("quedaran disponibles %d productos\n",tmp);
reporteVentas(dep,nom,cuantos,total);
if (tmp == 0)
{
lista=listaInt_remover(lista,venta);
reescribeArchivo(dep,lista);
}
else
{
lista=listaInt_remover(lista,venta);
lista = listaInt_ingresar(lista,tmp,v,nom);
reescribeArchivo(dep,lista);
}
listaInt_borrar(lista);
}
return lista;
}
}
NodoInt* eliminar(char dep[15], NodoInt *lista)
{
int eliminado;
lista=leerArchivo(dep,lista);
printf("Selecciona el producto que deseas eliminar \n");
imprime_productos(lista);
scanf("%d",&eliminado);
eliminado--;
lista=listaInt_remover(lista,eliminado);
reescribeArchivo(dep,lista);
return lista;
}
void MainWindow::on_botonLeer_clicked()
{
leerArchivo();
// QDir directorio;
// QString dir = directorio.homePath();
// std::string home = dir.toStdString();
// QString nomArchivo = ui->boxArchivo->toPlainText();
// std::string nombreArchivo = nomArchivo.toStdString();
// std::string ruta = "";
// if (nombreArchivo.rfind(".txt") != -1) {
// ruta = home + "/Desktop/" + nombreArchivo;
// }
// else {
// ruta = home + "/Desktop/" + nombreArchivo + ".txt";
// }
// LectorArchivos lector;
// std::vector<int> datos = lector.leer(ruta);
// switch (currentArbol){
// case 1:{
// // Avl
// for(int i = 0; i < datos.size(); i++){
// NodoB<int> *nuevo = new NodoB<int>(datos[i]);
// avl->insert(nuevo);
// }
// break;
// }
// case 2:{
// //Rojinegro
// for(int i = 0; i < datos.size(); i++){
// NodoB<int> *nuevo = new NodoB<int>(datos[i]);
// rojinegro->RBinsert(nuevo);
// }
// break;
// }
// case 3:{
// //2/3
// for(int i = 0; i < datos.size(); i++){
// NodoDosTres<int>*nuevo = new NodoDosTres<int>(datos[i]);
// dosTres->insertar23(nuevo);
// }
// break;
// }
// }
}
NodoInt* agregar(char dep[15],NodoInt *lista)
{
lista=leerArchivo(dep,lista );
char nuevoP[15];
int costo,cantidad;
printf("\nEscriba el nuevo nombre del producto: ");
scanf("%c",&nuevoP);
printf("\nEscriba el costo del producto: ");
scanf("%d",&costo);
printf("\nEscriba la cantidad inicial del producto: ");
scanf("%d",&cantidad);
lista = listaInt_ingresar(lista,cantidad,costo,nuevoP);
guardarArchivo(dep,cantidad,costo,nuevoP);
return lista;
}
int32_t rfs_read(int32_t sock, NIPC paqueteEnviar, char *path, size_t size,
off_t offset) {
extern t_log *loguear;
int32_t sizeOriginal = size;
char * buff = NULL;
int32_t numeroInodo = leerSubDirectorios(path);
if (numeroInodo != -1) {
subirOperacion(numeroInodo, 0);
usleep(retardo);
buff = leerArchivo(numeroInodo, size, offset, path, &sizeOriginal);
liberarMutexOperacion(numeroInodo);
if (buff != NULL) {
if (sizeOriginal == 0) {
crearNIPC(5, 1, sizeOriginal, sizeOriginal, buff,
&paqueteEnviar, 0);
// aca no va free porqe buf es "" :P
} else {
crearNIPC(5, 0, sizeOriginal, sizeOriginal, buff,
&paqueteEnviar, 0);
free(buff); // Ojo lo agrege reciennnnnn verificar
}
} else {
crearNIPC(5, 0, 3, 0, NULL, &paqueteEnviar, 0);
}
} else {
crearNIPC(5, 0, 3, 0, NULL, &paqueteEnviar, 0);
}
char* nombreDeArchivo = dameElNombre(path);
log_debug(loguear,
"Nombre De Archivo: %s- Operacion read- Size: %d- Offset: %d",
nombreDeArchivo, size, offset);
enviarNIPC(sock, paqueteEnviar);
chauNIPC(&paqueteEnviar);
return 0;
}
bool MainWindow::eventFilter(QObject *object, QEvent *event)
{
if (object == ui->insNum && event->type() == QEvent::KeyPress){
QKeyEvent *keyEvent = static_cast<QKeyEvent *>(event);
if (keyEvent->key() == Qt::Key_Return){
addNode();
return true;
}
else{
return QMainWindow::eventFilter(object, event);
}
}
else if (object == ui->borrarNum && event->type() == QEvent::KeyPress){
QKeyEvent *keyEvent = static_cast<QKeyEvent *>(event);
if (keyEvent->key() == Qt::Key_Return){
deleteNode();
return true;
}
else{
return QMainWindow::eventFilter(object, event);
}
}
else if (object == ui->buscNum && event->type() == QEvent::KeyPress){
QKeyEvent *keyEvent = static_cast<QKeyEvent *>(event);
if (keyEvent->key() == Qt::Key_Return){
buscarNodo();
return true;
}
else{
return QMainWindow::eventFilter(object, event);
}
}
else if (object == ui->boxArchivo && event->type() == QEvent::KeyPress){
QKeyEvent *keyEvent = static_cast<QKeyEvent *>(event);
if (keyEvent->key() == Qt::Key_Return){
leerArchivo();
return true;
}
else{
return QMainWindow::eventFilter(object, event);
}
}
else{
return QMainWindow::eventFilter(object, event);
}
}
int main(){
Tabla tabla[m];
inicializaRegistros();
clock_t start = clock();
leerArchivo("datos.txt");
printf("DATOS INGRESADOS\n");
/* if(buscarClave("I176S8C4J1V1")){
printf("\nClave encontrada\n");
}else{
printf("\nClave no encontrada\n");
}*/
printf("Tiempo de ejecucion = %f\n", ((double)clock() - start)/CLOCKS_PER_SEC);
// mostrarTabla();
return 1;
}
int main()
{
EMovie listaPeliculas[CANT];
inicalizarIsempty(listaPeliculas, CANT);
leerArchivo(listaPeliculas, CANT);
char seguir='s';
int opcion=0;
do
{
system("cls");
printf("1- Agregar pelicula\n");
printf("2- Borrar pelicula\n");
printf("3- Modificar pelicula\n");
printf("4- Generar pagina web\n");
printf("5- Salir\n");
scanf("%d",&opcion);
fflush(stdin);
switch(opcion)
{
case 1:
agregarPelicula(listaPeliculas,CANT);
break;
case 2:
borrarPelicula(listaPeliculas,CANT);
break;
case 3:
modificarPelicula(listaPeliculas,CANT);
break;
case 4: listar(listaPeliculas, CANT);
break;
case 5:
seguir = 'n';
break;
default:printf("Ingrese opciones de 1 a 5");
}
system("pause");
} while(seguir=='s');
return 0;
}
void ejecutarBubblesort(char* nombreArchivo) {
int i, size;
char** palabras = leerArchivo(nombreArchivo, &size);
if (!palabras)
return;
/*Ordeno*/
bubblesort(palabras,size);
/*Imprimo el resultado y libero memoria*/
for(i=0;i<size;i++){
printf("%s ",palabras[i]);
free(palabras[i]);
}
free(palabras);
printf("\n");
}
int main()
{
Producto m_producto ;
Producto proAux[20];
FILE *ptr;
char name[T_P];
int opc ;
do
{
opc = muestraMenu();
switch( opc )
{
case 1:
leerNombre( name );
crearArchivo( name, ptr );
break;
case 2:
leerNombre( name );
escribeArchivo( name, ptr, m_producto, &nPro ) ;
break;
case 3:
leerNombre( name );
leerArchivo( name, ptr, m_producto, nPro );
break;
case 4:
leerNombre( name );
determinaTotal( name, ptr, m_producto, proAux, nPro);
break;
case 5: break;
}
}while ( opc != 5 );
system ( "pause" );
}
int main (int argc, char **argv)
{
clock_t start = clock();
int index;
int c;
opterr = 0;
while ((c = getopt (argc, argv, "f:")) != -1)
switch (c)
{
case 'f':
printf("Leyendo archivo[%s]...\n", optarg);
float *F=leerArchivo(optarg);
printf("%f\n",sumar(F));
break;
case '?':
if (optopt == 'f')
fprintf (stderr, "Opcion -%c requiere la direccion del archivo.\n", optopt);
else if (isprint (optopt))
fprintf (stderr, "Unknown option `-%c'.\n", optopt);
else
fprintf (stderr,
"Unknown option character `\\x%x'.\n",
optopt);
return 1;
default:
abort ();
}
for (index = optind; index < argc; index++)
printf ("Non-option argument %s\n", argv[index]);
printf("\nTiempo transcurrido: %f", ((double)clock() - start) / CLOCKS_PER_SEC);
return 0;
}
void doEcho(char* line)
{
char* nombre = getargument(line);
leerArchivo(nombre);
}
/**
* Programa principal
*
* @param argc Número de parametros con el que se hizo la invocación
* programa.
* @param argv Valores de los argumentos pasados al programa por línea de
* comandos. Los valores válidos corresponden con lo especificado en
* la descripción del proyecto.
*
* @author Jerilyn Goncalves, 05-38242
* @author Victor de Ponte, 05-38087
*/
int main (int argc, char **argv) {
///Tiempo en segundos entre cada verificación. Valor por defecto: 30s
int t;
/**
* TRUE si se especificó un directorio por linea de comandos;
* FALSE en caso contrario.
*/
int dir_especificado = 0;
/**
* TRUE si se especificó un archivo por linea de comandos;
* FALSE en caso contrario.
*/
int arch_especificado = 0;
/**
* Contendra el nombre ya sea del único directorio a verificar, o del archivo
* a leer el cual contendrá un URL por linea de un directorio a modificar.
*/
char *aVerificar;
procesarArgumentos(argc,argv,&t,&aVerificar,&dir_especificado,
&arch_especificado);
if (dir_especificado) {
directorios = (char **) xmalloc(1*sizeof(char*));
directorios[0] = aVerificar;
} else {
ListaStr *dirs = leerArchivo(aVerificar);
n = dirs->size;
directorios = LSToArray(dirs);
LSLiberar(dirs);
free(dirs);
}
pids = (pid_t *) xmalloc(n * sizeof(pid_t));
signal(SIGCHLD, childHandler); // se instala el nuevo manejador para SIGCHLD
printf("Bienvenido al monitor de directorios remotos!\n");
ayuda_cli();
printf("\n");
register int i;
for (i = 0; i < n; i++) {
char* intervalo = xmalloc(sizeof(char*));
sprintf(intervalo, "%d", t);
if ((pids[i]=fork())==0) {
execl("./verificador", "./verificador", directorios[i], intervalo, NULL);
}
}
char key;
while (TRUE) {
key = getChar();
switch(key)
{
case 'h':
ayuda_cli();
break;
case 's':
printf("Instrucción recibida: STOP\n");
mens_despedida();
matarHijos();
sleep(2);
exit(0);
break;
case 'c':
printf("Instrucción recibida: CONTINUE\n");
continuarHijos();
mens_continuar();
break;
case 'p':
printf("Instrucción recibida: PAUSE\n");
pausarHijos();
mens_pausado();
break;
default:
printf("Instrucción desconocida recibida: %c\n",key);
}
}
free(directorios);
return 0;
}
int main(int argc, char const *argv[]) {
int termino = 0, offsetHost = 0;
if (argv[1] == string("CSPLib")) {
while (!termino) {
// Configuración
string NOMBRE_INSTANCIA = argv[2];
int ITERACIONES_TS = atoi(argv[3]), LARGO_LISTA_TABU = atoi(argv[4]);
// Declaración de variables
string PATH = "Instancias PPP/Instancias CSPLib/";
clock_t t_ini, t_fin;
map<int, int> posicionesGuests;
vector<int> hosts;
double secs;
pair <int, matrix> resultado;
matrix matrizInicial;
PPP problema;
int CANTHOSTS;
// Leyendo archivo de la instancia
problema = leerArchivo(PATH + NOMBRE_INSTANCIA + ".txt");
// Seteando hosts y guests
CANTHOSTS = problema.T + offsetHost;
vector< pair<int, int> > yatesHosts = getNMayores(CANTHOSTS, problema.vtrK);
for(unsigned i = 0; i < yatesHosts.size(); ++i)
hosts.push_back(yatesHosts[i].second);
posicionesGuests = getPosicionGuests(problema.Y, hosts);
// Ejecutando algoritmos
t_ini = clock();
matrizInicial = greedy(posicionesGuests, hosts, problema);
resultado = tabuSearch(matrizInicial, posicionesGuests, hosts, problema, ITERACIONES_TS, LARGO_LISTA_TABU);
t_fin = clock();
if (resultado.first != 0) {
offsetHost++;
continue;
}
secs = (double) (t_fin - t_ini) / CLOCKS_PER_SEC;
// Escribiendo el archivo de salida
escribirOutput(NOMBRE_INSTANCIA, hosts, posicionesGuests, resultado.second, problema, secs, resultado.first);
termino = 1;
}
}
else if (argv[1] == string("PPP")) {
// Configuración
int ITERACIONES_TS = atoi(argv[3]), LARGO_LISTA_TABU = atoi(argv[4]);
// Declaración de variables
string NOMBRE_INSTANCIA, ARCHIVO_SALIDA;
string PATH = "Instancias PPP/";
clock_t t_ini, t_fin;
map<int, int> posicionesGuests;
vector<int> hosts;
double secs;
pair <int, matrix> resultado;
matrix matrizInicial;
PPP problema;
// Leyendo archivo de la instancia y seteando hosts y guests
if (argv[2] == string("m1")) {
NOMBRE_INSTANCIA = string(argv[1]) + "_m1";
hosts = leerArchivoConfig(PATH + "Configuraciones/Configuraciones_m1.txt")["pp1_m"];
ARCHIVO_SALIDA = NOMBRE_INSTANCIA;
}
else if (argv[2] == string("m2")) {
NOMBRE_INSTANCIA = string(argv[1]) + "_m2";
hosts = leerArchivoConfig(PATH + "Configuraciones/Configuraciones_m2.txt")["pp1_m2"];
ARCHIVO_SALIDA = NOMBRE_INSTANCIA;
}
else {
NOMBRE_INSTANCIA = string(argv[1]);
hosts = leerArchivoConfig(PATH + "Configuraciones/Configuraciones.txt")[argv[2]];
ARCHIVO_SALIDA = NOMBRE_INSTANCIA + "_" + string(argv[2]);
}
// Leyendo archivo de la instancia
problema = leerArchivo(PATH + NOMBRE_INSTANCIA + ".txt");
posicionesGuests = getPosicionGuests(problema.Y, hosts);
// Ejecutando algoritmos
t_ini = clock();
matrizInicial = greedy(posicionesGuests, hosts, problema);
cout << "Trabajando... Si es que el problema es PPP normal se demora entre 2 a 3 minutos." << endl << endl;
resultado = tabuSearch(matrizInicial, posicionesGuests, hosts, problema, ITERACIONES_TS, LARGO_LISTA_TABU);
t_fin = clock();
secs = (double) (t_fin - t_ini) / CLOCKS_PER_SEC;
// Escribiendo el archivo de salida
escribirOutput(ARCHIVO_SALIDA, hosts, posicionesGuests, resultado.second, problema, secs, resultado.first);
}
return 0;
}
//METODO CONSTRUCTOR
int main()
{
cabeza = NULL;
cabeza1 = NULL;
raiz = NULL;
int seleccion;
clock_t t1,t2;
float t_ordenarBurbuja, t_ordenarQuicksort, t_insercion, t_recorido;
//MENU DE LA APLICACION
do{
system("clear");
if(seleccion==CARGAR){//CARGA LOS ARCHIVOS
cabeza = leerArchivo(cabeza);
t1=clock();
raiz = insertaArbol(cabeza, raiz);
t2=clock();
t_insercion = (float)(t2-t1)/(float)(CLOCKS_PER_SEC);
cabeza1 = insertarLista(cabeza, cabeza1);
printf("El tiempo que tardo la inseccion = %f\n", (float)(t2-t1)/(float)(CLOCKS_PER_SEC));
}
if(seleccion==IMPRIMIR){//IMPRIME AMBOS DATOS
printf("Quicksort\n");
Imprimir(cabeza1);
printf("Burbuja\n");
Imprimir(cabeza);
printf("Los datos del arbol son: \n");
t1=clock();
inOrden(raiz);
t2=clock();
t_recorido = (float)(t2-t1)/(float)(CLOCKS_PER_SEC);
printf("\nEl tiempo que tardo en realizar el recorrido = %f\n", (float)(t2-t1)/(float)(CLOCKS_PER_SEC));
}
if(seleccion==ORDENAR){
t1=clock();
quicksirt(cabeza1, cantidad(cabeza1));
t2=clock();
t_ordenarBurbuja = (float)(t2-t1)/(float)(CLOCKS_PER_SEC);
t1=clock();
cabeza = ordenar(cabeza);
t2=clock();
t_ordenarQuicksort = (float)(t2-t1)/(float)(CLOCKS_PER_SEC);
}
if(seleccion==REPORTE){
printf("REPORTE DE TIEMPOS \n\n");
printf("Ingresar al arbol: %f\n", t_insercion);
printf("Recorrido del arbol: %f\n", t_recorido);
printf("Ordenado burbuja: %f\n", t_ordenarBurbuja);
printf("Ordenado quicksort: %f\n", t_ordenarQuicksort);
}
if(seleccion==DIAGRAMA){
graficar(t_insercion, t_recorido, t_ordenarBurbuja, t_ordenarQuicksort, cantidad(cabeza));
}
if(seleccion == 9){
int n;
scanf("%d", &n);
printf("dato = %d\n", getNodo(cabeza1, n)->dato);
}
printf("\n------------------------- MENU ---------------------------\n");
printf("0. Salir \n");
printf("1. Leer Archivo \n");
printf("2. Imprimir \n");
printf("3. Ordenar Listas \n");
printf("4. Reporte \n");
printf("5. Diagrama \n");
printf("6. Limpiar Consola \n");
printf("-------------- Selecione una de las opciones ---------------\n");
scanf("%d", &seleccion);
}while(seleccion!=0);
system("clear");
printf("LA APLICACION TERMINO SU PROCESO \n");
return 0;
}