Angels



She offers me protection a lot of love and affection

¡Saludos! @fferegrino :(
Publicado por a las 4:33 PM No comments Editar entrada
,

Banco - Aplicación con colas (B)

También para linux

Igual requiere de: pilas.h y pilas.c que encuentras en en la entrada anterior.

/* 
 * Archivo:   Banco.c
 * Autores: Rodrigo y Antonio
 *
 * Creado el 17 de febrero de 2011, 09:30 PM
 */

#include "colas.h"

int main() {

    cola *Fila_Banco = crear_c();//Creamos una nueva pila
    int tiempo_espera = 0;//Esta variable controlará el tiempo de espera.
    int menu = 0;//Variable para el menu principal
    do{
        printf("Banco Bonito :D\n");
        printf("Menú de administrador:\n\t1)Llegada de cliente\n\t2)Salida de cliente\n\t3)Salir\n");
        printf("Elige: ");
        scanf("%d",&menu);
        switch(menu)//Opciones de administrador
        {
            case 1://Recibimos al cliente
                printf("\n\n\n\tNuevo cliente\n");
                tipodato nuevo_cliente;//Creamos una nueva estructura
                printf("Introduce el nombre del cliente: ");
                getchar();//Evitar retorno de carro, Linux ;)
                nuevo_cliente.nombre =(char *) calloc(51,sizeof(char));//Reservar memoria para el nombre del cliente
                gets(nuevo_cliente.nombre);//Obtener el nombre del cliente
                int tiempo_operaciones = 0;//Aquí se guardará el tiempo de operaciones del nuevo cliente
                int submenu = 0;//Variable para el submenu
                do{
                    printf("\nElija la(s) operacion(es) que %s realizará:\n",nuevo_cliente.nombre);
                    printf("\t1)Depósito\n\t2)Retiro\n\t3)Cobro de cheques\n\t4)Depósito a terceros\n\t5)Consulta de saldo\n\t6)Nada");
                    printf("\nElige: ");
                    scanf("%d",&submenu);
                    switch(submenu)//Se acumula el tiempo de operaciones del nuevo cliente
                    {
                        case 1: tiempo_operaciones += 5; break;
                        case 2: tiempo_operaciones += 6; break;
                        case 3: tiempo_operaciones += 8; break;
                        case 4: tiempo_operaciones += 4; break;
                        case 5: tiempo_operaciones += 2; break;
                        default: break;
                    }
                }while(submenu != 6);
                nuevo_cliente.tiempo = tiempo_operaciones;//Se guarda en la estructura el tiempo total de operaciones de el cliente nuevo
                if(introducir_c(nuevo_cliente,Fila_Banco))
                {
                    printf("\n\n\t%s está formado y va a esperar %d minutos para ser atendido\n\n",nuevo_cliente.nombre,tiempo_espera);//Desplegar información
                }
                tiempo_espera += tiempo_operaciones;//Se suma el tiempo de operaciones al tiempo de espera global
                break;
            case 2://Atendemos al cliente
                if(vacia_c(Fila_Banco))//Si la cola está vacía
                {
                    printf("\t\nLa fila está vacía, ya atendiste a todos tus clientes... o nunca has tenido clientes  :P\n");
                }
                else
                {
                    tipodato cliente_atendido = sacar_c(Fila_Banco);//Se saca el cliente de la cola
                    if(!(cliente_atendido.nombre == NULL)){
                        printf("\t\nWoha! se ha atendido a %s\n", cliente_atendido.nombre);
                        tiempo_espera -= cliente_atendido.tiempo;//Un cliente sacado de la cola es un cliente atendido, se resta su tiempo de atención al tiempo global de espera
                    }
                }
                break;
            case 3: break;
            default: break;
        }
    }while(menu != 3);
    return (EXIT_SUCCESS);
}

¡Saludos! @fferegrino :)

Banco - Aplicación con colas.

Para Windows

Requerimos el uso de las funciones básicas de colas, que están en estos links: colas.h colas.c Código fuente: 
/* 
 * File:   main.cpp
 * Author: Rodrigo y ToñoGates
 */

#include 
#include "colas.h"

void imprimemenu();
void menu_transacciones();
int calcular_tiempo(int []);
int tiempo_espera(Cola *c);

int main(int argc, char** argv) {
char ch;
int num=0;
//clrscr();
printf("\n\t\t\t Toño&Rod´s Bank \n\n\n ¿Deseas hacer una Cola de clientes? S/N\n");
scanf("%c",&ch);
    if((ch == 'N')||(ch == 'n')){
        printf("Salgo del programa\n");
        return (EXIT_SUCCESS);
    }
int t_espera=0;
 int i=0;

int trans[10]={0};
Cola *c;
c=crear();
TipoDato p1;
p1.nombre=(char *)calloc(100,sizeof(char));
do{
    imprimemenu();
    scanf("%d",&num);
    switch (num)
    {
     case 1:
  i=0;
                printf("\n\tNombre:");
                getchar();
                gets(p1.nombre);
                printf("\n\n\tTransaccion(es)a realizar(10 max):");
                do{
                 menu_transacciones();
                 scanf("%d",&trans[i]);
   printf("\n¿Desea realizar otra transacción? S/N");
                 getchar();
                 scanf("%c",&ch);
                     if((ch == 'N')||(ch == 'n')){
                         printf("Listo");
                         num=7;
                     }else i++;
                }while(num!=7);
                t_espera=tiempo_espera(c);
                printf("\nFaltan %d",t_espera);
                printf(" minutos.");
                p1.tiempo=calcular_tiempo(trans);
                if(insertar(c,p1))
                 printf("\n\n\nCliente introducido con éxito");
                else 
                    printf("\n\n\nLo sentimos tu Cliente no se pudo insertar...");
                break;
            case 2:
                if(vacia(c)) printf("\nLa Cola esta vacía. \n");
                else{
                 printf("\nAtendiendo a ...");
                 TipoDato dat=eliminar(c);
                 printf("\n %s",dat.nombre);
                }
                break;
            case 3:
                if(vacia(c)) printf("\nCola vacía");
                else{
                 printf("\nEstos son tus clientes en espera...\n");
                 mostrar(c);
                }
                break;
     }
  }while (num!=4);
  return EXIT_SUCCESS;
}
Las funciones básicas son desarrolladas: 
int calcular_tiempo(int trans[]){
    int t,suma=0;
    for(int i=0;i<11;i++){
        switch(trans[i]){
            case 1: t=5; break;
            case 2: t=6; break;
            case 3: t=8; break;
            case 4: t=4; break;
            case 5: t=2; break;
            default: t=0; break;
 }
        suma=suma+t;
    }
    return suma;
};

int tiempo_espera(Cola *c){
    int suma=0;
    Nodo  *aux=c->frente;
        while(aux!=NULL){
            suma+=aux->dato.tiempo;
            aux=aux->atras;
        }
 return suma;
};
¡Saludos! @fferegrino :)

Sound Matrix


Súbele a tus bocinas y luego da click en cualquiera de los cuadritos.
Desestresate, diviértete y comparte.


Vía: Sembeo


¡Saludos! @fferegrino :)
Publicado por a las 9:07 PM No comments Editar entrada
, ,

Corazón Atómico


i just don't know where i'm going,
but i know where i'll stay.

Ya sé, ya sé muchas canciones últimamente, pero es lo que hay.

¡Saludos! @fferegrino :D
Publicado por a las 5:33 PM No comments Editar entrada
,

Infijo => Postfijo

Hacer un programa en C que mediante el uso de pilas, transforme una expresión infija a una postfija, nada complicado(en teoría).

Requiere el uso de estos 2 archivos:

pilas.h
pilas.c

Algoritmo y código:
/* 
* Archivo: main.c
* Autores: Antonio Feregrino y Rodrigo Benavides
*
* Creado el 14 de febrero de 2011, 08:22 PM
*/

#include "pilas.h"

int comprobar(char);
int precedencia(char);

/*
* 
*/
int main() {
char primera_expresion[50];//Cadena inicial
char *cadenita_auxiliar = calloc(50+1,sizeof(char));//Cadena final
pila *operadores = crear();//Se crea la pila de los operadores
printf("Introduce la expresión a convertir: \n\n");
gets(primera_expresion);//Se lee la expresion principal
int i = 0, i_cadenita = 0;//Variables usadas para recorrer los arreglos de caracteres
while(primera_expresion[i] != '\0'){//Mientras que la expresión principal no se termine

switch(comprobar(primera_expresion[i])){//Comprobación del tipo de caracter 1 a 1
case 1://En este caso el caracter es un parentesis de apertura (
push(primera_expresion[i],operadores);
break;
case 2://En este caso el caracter es un parentesis de cierre )
while(muestra_ultimo(operadores) != '('){//Mientras que el último elemento de la pila no sea (
cadenita_auxiliar[i_cadenita] = pop(operadores);//Saca los operadores de la pila y colocalos en la cadena final
i_cadenita++;//Aumenta el índice de la cadena final para no sobreescribirla
}
pop(operadores);//Saca el paréntesis de apertura (
break;
case 3://En este caso el caracter es un operando [a-zA-Z0-9]
cadenita_auxiliar[i_cadenita] = primera_expresion[i];//Se introdue directamente a la cadena final
i_cadenita++;//Aumenta el índice de la cadena final para no sobreescribirla
break;
case 4://En este cuarto y último caso, el caracter es un operador [+-/%^]
if(vacia(operadores)){//Si la pila esta vacía
push(primera_expresion[i],operadores);//Introduce el operador
}else{//Si no está vacía
int operador_nv = precedencia(primera_expresion[i]);//Se calcula la precedencia del caracter a evaluar
int operador_ol = precedencia(muestra_ultimo(operadores));//Se calcula la precedencia de la cima
if( operador_nv > operador_ol)//Si la precedencia del nuevo es mayor a la de la cima
{
push(primera_expresion[i],operadores);//Introduce el operador
}
else//Si es menor o igual
{
do{
cadenita_auxiliar[i_cadenita] = pop(operadores);//Saca la cima e introducela en la cadena final
i_cadenita++;//Aumenta el índice de la cadena final para no sobreescribirla
operador_ol = precedencia(muestra_ultimo(operadores));//Calcula la precedencia de la nueva cima
}while(!(operador_nv > operador_ol));//Repite esto hasta que la precedencia del nuevo sea mayor a la de la cima
push(primera_expresion[i],operadores);//Introduce el nuevo operador en la cima de la pila
}
}
break;

}
i++;//Recorre en uno el índice de la expresión inicial
} 
printf("Tu expresión postfija es: %s\n",cadenita_auxiliar);//Muestra la cadena final
return (EXIT_SUCCESS);
}

int comprobar(char t){
/* Función que comprueba que caracter es, regresa valores enteros segun sea el caso */
if( t == '(' ) return 1;
if( t == ')' ) return 2;
if(( t <= 90 && t >=65 ) || ( t <= 122 && t >= 97 ) || ( t <= 57 && t >=48 )) return 3;
if( t == '*' || t == '+' || t == '^' || t == '/' || t == '-') return 4;
else return 0;
}

int precedencia(char t){
/* Aquí es calculada la precedencia personalizada de los operadores */
if( t == '^' ) return 3;
if( t == '*' || t == '/' || t == '%' ) return 2;
if( t == '+' || t == '-' ) return 1;
if( t == '(' || t == ')' ) return 0;
else return 0;
}


No es el mejor algoritmo pero es lo más que pudimos hacer mi compañero y amigo @frescasandia y yo.


Igual no se si esté permitido por la profesora @bellims hacer esto ;$

¡No al plagio!

¡Saludos! @fferegrino :)

Take this waltz




Now in Vienna there's ten pretty women
There's a shoulder where Death comes to cry
There's a lobby with nine hundred windows
There's a tree where the doves go to die
There's a piece that was torn from the morning

¡Saludos! @fferegrino :(
Publicado por a las 8:56 PM No comments Editar entrada
,
Newer Posts
Home
Older Posts