Programa del Banco

September 27, 2007 Leave a comment

/* Este codigo se encuentra en lenguaje C++ */

#include <cstdlib>
#include <iostream>

using namespace std;
typedef struct {string nombre; string apellido; int cuenta; float balance;} Client;

int Buscar (string nombre, string apellido, Client clientes[], int y )
{  while(y >= 0)
{  if (clientes[y].nombre == nombre && clientes[y].apellido == apellido)
return y;
y–;
}
return -1;
}

int id(Client clientes[], int y)
{  string nombre, apellido;
cout << “\nNuevo cliente:\n”;
cout << “\n Nombre:\t”;
cin >> nombre;
cout << ” Apellido:\t”;
cin >> apellido;
if(Buscar(nombre, apellido, clientes, y) >= 0)
{cout << “\n ** Este cliente ya existe **\n”;
cout << “\n — o — o — o — o — \n”;
return 0;}
clientes[y].nombre = nombre;
clientes[y].apellido = apellido;
clientes[y].cuenta = y;
cout << ” Cuenta #:\t” << clientes[y].cuenta << “\n”;
clientes[y].balance = 0.0;
cout << ” Balance:\t$” << clientes[y].balance << “\n”;
cout<<“\n — o — o — o — o — \n”;
return 1;
}

int Busqueda(Client clientes[], int y)
{ int e;
string nombre, apellido;
cout << “\nBusqueda de estudiante:\n”;
cout << “\n Nombre:\t”;
cin >> nombre;
cout << ” Apellido:\t”;
cin >> apellido;
e = Buscar(nombre, apellido, clientes, y);
if( e == -1 )
{cout << “\n ** No se encuentra el cliente **\n”;
cout << “\n — o — o — o — o — \n”;
return -1;}
cout << ” Cuenta #:\t” << clientes[e].cuenta << “\n”;
cout << ” Balance:\t$” << clientes[e].balance << “\n”;
cout<<“\n — o — o — o — o — \n”;
return e;
}

void Print(Client clientes[], int y)
{
cout << “\n Nombre:\t” << clientes[y].nombre << “\n”;
cout << ” Apellido:\t” << clientes[y].apellido << “\n”;
cout << ” Cuenta #:\t” << clientes[y].cuenta << “\n”;
cout << ” Balance:\t$” << clientes[y].balance << “\n”;
cout<<“\n — o — o — o — o — \n”;
}

int main(int argc, char *argv[])
{
Client clientes[500];
char x, y;
int cuentas = 0;

while(!0){
cout<<“\n\t—-> Menu <—-\n\n\t1)Nuevo cliente\n\t2)Buscar cliente\n\t0)Salir\n”;
cout<<“–> “;
cin>>x;

if(x == ‘0’ || x == ‘s’)
break;

switch(x){
case (‘1’):
case (‘n’):
id(clientes, cuentas);
cuentas++;
break;
case (‘2’):
case (‘b’):
int e;
float money;
e = Busqueda(clientes, cuentas);
if ( e == -1)
break;
cout << “\n\t1)Depositar\n\t2)Retirar\n\t0)Salir\n–> “;
cin >> y;
switch (y){
case ‘1’:
case ‘d’:
cout << “\n Cantidad a depositar: “;
cin >> money;
clientes[e].balance += money;
Print(clientes,e);
break;
case ‘2’:
case ‘r’:
cout << “\n Cantidad a retirar: “;
cin >> money;
if(money > clientes[e].balance)
{ cout << “\n ** No hay balance suficiente **\n”;
cout << “\n — o — o — o — o — \n”;
break; }
clientes[e].balance -= money;
Print(clientes,e);
break;
case ‘0’:
case ‘s’:
break;
default:
cout << “\n\n ** Opcion no valida \n**”;
}
break;
default:
cout << “\n\n Opcion No Valida\n”;
cout << “\n — o — o — o — o — \n”;
break; } }

//system(“PAUSE”);
return EXIT_SUCCESS;
}

Categories: Programacion I

Programa de tickets

September 27, 2007 Leave a comment

/* Este codigo se encuentra en lenguaje C++ */

#include <cstdlib>
#include <iostream>

using namespace std;

int Venta(int sits[],int price[], int x, int& balance)
{    int cantidad, total;
cout << “\n Cantidad de taquillas: “;
cin >> cantidad;
if ( cantidad > sits[x])
{ cout << “\n ** No hay suficientes taquillas **\n”;
cout << “\n — o — o — o — o — \n”;
return -1; }
sits[x] -= cantidad;
total = cantidad * price[x];
balance += total;
return cantidad;
}

int main(int argc, char *argv[])
{
int sits[4];
int price[4];
int e, balance = 0;

sits[0] = 20; sits[1] = 40; sits[2] = 100; sits[3] = 80;
price[0] = 500; price[1] = 300; price[2] = 150; price[3] = 50;

char x;

while(!0){

cout << “\n Asientos Disponibles/Precios\n\n”;
cout << ”   V.I.P.:\t” << sits[0] << “/$” << price[0] << “\n”;
cout << ”   Palco:\t” << sits[1] << “/$” << price[1] << “\n”;
cout << ”   Grada:\t” << sits[2] << “/$” << price[2] << “\n”;
cout << ”   Blicher:\t” << sits[3] << “/$” << price[3] << “\n”;
cout << “\n    Balance:\t$” << balance << “\n”;

cout << “\n   —–> Menu <—–\n\n\t1)V.I.P.\n\t2)Palco\n\t3)Grada\n\t4)Blicher\n\t0)Salir\n”;
cout << “–> “;
cin >> x;

if(x == ‘0’ || x == ‘s’)
break;

switch(x){
case (‘1’):
e = Venta(sits, price, 0, balance);
if ( e == -1)
break;
cout << “\n ” << e << ” taquillas V.I.P.\tTotal: $” << e * price[0] << “\n”;
cout << “\n — o — o — o — o — \n”;
break;
case (‘2’):
e = Venta(sits, price, 1, balance);
if ( e == -1)
break;
cout << “\n ” << e << ” taquillas Palco\tTotal: $” << e * price[1] << “\n”;
cout << “\n — o — o — o — o — \n”;
break;
case (‘3’):
e = Venta(sits, price, 2, balance);
if ( e == -1)
break;
cout << “\n ” << e << ” taquillas Grada\tTotal: $” << e * price[2] << “\n”;
cout << “\n — o — o — o — o — \n”;
break;
case (‘4’):
e = Venta(sits, price, 3, balance);
if ( e == -1)
break;
cout << “\n ” << e << ” taquillas Blicher\tTotal: $” << e * price[3] << “\n”;
cout << “\n — o — o — o — o — \n”;
break;
default:
cout << “\n\n Opcion No Valida\n”;
cout << “\n — o — o — o — o — \n”;
break; }
}
//system(“PAUSE”);
return EXIT_SUCCESS;
}

Categories: Programacion I

Programa de notas

September 27, 2007 Leave a comment

/* Este codigo se encuentra en lenguaje C++ */

#include <cstdlib>
#include <iostream>
#include <string>

using namespace std;
typedef struct {string nombre; string apellido; int Mat[5]; int promedio;} Alumno;

int Buscar (string nombre, string apellido, Alumno Est[], int y )
{
while(y>=0)
{
if (Est[y].nombre == nombre && Est[y].apellido == apellido)
{return y;}
y–;
}
return -1;
}

int RegAlum (Alumno Est[], int y)
{
string nombre, apellido;
cout<<“\nNuevo Ingreso:\n”;
cout<<“\n Nombre:\t”;
cin>>nombre;
cout<<” Apellido:\t”;
cin>>apellido;
if(Buscar(nombre, apellido, Est, y)>=0)
{cout<<“\n ** Este alumno ya existe **\n”;
cout<<“\n — o — o — o — o — \n”;
return 0;}
Est[y].nombre = nombre;
Est[y].apellido = apellido;
return 1;
}

int InsNota (string nombre, string apellido, Alumno Est[], int y)
{
int e;
e=Buscar(nombre,apellido,Est,y);
if (e==-1){cout<<“\nNo se encuentra el estudiante.\n”;
cout<<“\n — o — o — o — o — \n”;
return 1;}
cout<<“\nInserte las siguientes notas:”;
cout<<“\n Ingles:\t\t”;
cin>>Est[e].Mat[0];
cout<<” Espanol:\t\t”;
cin>>Est[e].Mat[1];
cout<<” Matematicas:\t\t”;
cin>>Est[e].Mat[2];
cout<<” Ciencias Sociales:\t”;
cin>>Est[e].Mat[3];
cout<<” Ciencias Naturales:\t”;
cin>>Est[e].Mat[4];
return e;
}

int Imp (string nombre, string apellido, Alumno Est[], int y)
{
int e;
e=Buscar(nombre,apellido,Est,y);
if (e==-1){cout<<“\nNo se encuentra el estudiante.\n”;
cout<<“\n — o — o — o — o — \n”;
return 1;}
cout<<“\n Ingles:\t\t”<<Est[e].Mat[0]<<“\n”;
cout<<” Espanol:\t\t”<<Est[e].Mat[1]<<“\n”;
cout<<” Matematica:\t\t”<<Est[e].Mat[2]<<“\n”;
cout<<” Ciencias Sociales:\t”<<Est[e].Mat[3]<<“\n”;
cout<<” Ciencias Naturales:\t”<<Est[e].Mat[4]<<“\n”;
cout<<”   Promedio:\t\t”<<Est[e].promedio<<“\n”;
return 0;
}

int Prom ( Alumno Est[], int y)
{ int x = 0;
Est[y].promedio = 0;
while(x <= 4)
{Est[y].promedio += Est[y].Mat[x];
x++;}
Est[y].promedio /= x;
cout<<”   Promedio:\t\t”<<Est[y].promedio<<“\n”;
cout<<“\n — o — o — o — o — \n”;
return 0;
}

int main(int argc, char *argv[])
{
Alumno Est[500];

string nombre,apellido;
char x=!’0′;
int y=0;
while (!0)
{
cout<<“\n\t—-> Menu <—-\n\n\t1)Nuevo alumno\n\t2)Buscar alumno\n\t3)Editar notas\n\t0)Salir\n”;
cout<<“–> “;
cin>>x;
if(x==’0′ || x==’s’)
break;
switch(x)
{
case (‘1’):
case (‘n’):if(RegAlum(Est, y))
{InsNota (Est[y].nombre,Est[y].apellido,Est,y);
Prom ( Est, y);
y++;}
break;
case (‘2’):
case (‘b’):
cout<<“\nBusqueda de estudiante:\n”;
cout<<“\n Nombre:\t”;
cin>>nombre;
cout<<” Apellido:\t”;
cin>>apellido;
Imp (nombre,apellido,Est,y);break;
case (‘3’):

cout<<“\nBusqueda de estudiante:\n”;
cout<<“\n Nombre:\t”;
cin>>nombre;
cout<<” Apellido:\t”;
cin>>apellido;
Prom ( Est, InsNota (nombre,apellido,Est,y));
break;
default: cout<<“\n Opcion No Valida\n”;
cout<<“\n — o — o — o — o — \n”;
break;
}
}
//system(“PAUSE”);
return EXIT_SUCCESS;
}

Categories: Programacion I

Fases del proceso de Compilacion

September 20, 2007 2 comments

Estructura de un Compilador.

Cualquier compilador debe realizar dos tareas principales: análisis del programa a compilar y síntesis de un programa en lenguaje maquina que, cuando se ejecute, realizara correctamente las actividades descritas en el programa fuente. Para el estudio de un compilador, es necesario dividir su trabajo en fases. Cada fase representa una transformación al código fuente para obtener el código objeto. La siguiente figura representa los componentes en que se divide un compilador. Las tres primeras fases realizan la tarea de análisis, y las demás la síntesis. En cada una de las fases se utiliza un administrador de la tabla de símbolos y un manejador de errores.

Análisis Léxico.
En la fase de análisis léxico se leen los caracteres del programa fuente y se agrupan en cadenas que representan los componentes léxicos. Cada componente léxico es una secuencia lógicamente coherente de caracteres relativa a un identificador, una palabra reservada, un operador o un carácter de puntuación. A la secuencia de caracteres que representa un componente léxico se le llama lexema (o con su nombre en inglés token). En el caso de los identificadores creados por el programador no solo se genera un componente léxico, sino que se genera otro lexema en la tabla de símbolos.

Análisis Sintáctico.
En esta fase, los componentes léxicos se agrupan en frases gramaticales que el compilador utiliza para sintetizar la salida.

Análisis Semántico.
La fase de análisis semántico se intenta detectar instrucciones que tengan la estructura sintáctica correcta, pero que no tengan significado para la operación implicada.

Generación de código Intermedio.
Algunos compiladores generan una representación intermedia explícita del programa fuente, una vez que se han realizado las fases de análisis. Se puede considerar esta operación intermedia como un subprograma para una máquina abstracta. Esta representación intermedia debe tener dos propiedades importantes: debe ser fácil de producir y fácil de traducir al programa objeto.

Optimización de Código.
En esta fase se trata de mejorar el código intermedio, de modo que resulte un código de máquina más rápido de ejecutar.

Generación de Código.
Esta constituye la fase final de un compilador. En ella se genera el código objeto que por lo general consiste en código en lenguaje máquina (código relocalizable) o código en lenguaje ensamblador.

Administrador de la tabla de símbolos.
Una tabla de símbolos es una estructura de datos que contiene un registro por cada identificador. El registro incluye los campos para los atributos del identificador. El administrador de la tabla de símbolos se encarga de manejar los accesos a la tabla de símbolos, en cada una de las etapas de compilación de un programa.

Manejador de errores.
En cada fase del proceso de compilación es posibles encontrar errores. Es conveniente que el tratamiento de los errores se haga de manera centralizada a través de un manejador de errores. De esta forma podrán controlarse más eficientemente los errores encontrados en cada una de las fases de la compilación de un programa.

Categories: Programacion I

Tipos de Variables

September 20, 2007 Leave a comment

Tipos de Variables por su arquitectura y su rango.

data type

32 size (bits)

64 size (bits)

Range

 

 

 

 

char

8

8

signed: -128 to 127 unsigned: 0 to 255

short

16

16

signed: -32768 to 32767 unsigned: 0 to 65535

int

32

32

signed: -2147483648 to 2147483647 unsigned: 0 to 4294967295

long

32

64

signed: -2147483648 to 2147483647 unsigned: 0 to 4294967295

float

32

32

3.4e +/- 38 (7 digits)

double

64

64

1.7e +/- 308 (15 digits)

long double

128

128

1.7e +/- 308 (15 digits)

Categories: Programacion I

Triangulo de Pascal

September 20, 2007 2 comments

/* Este programa se encuentra en lenguaje C */

#include <stdio.h>
#include <stdlib.h>

/* —o — o —o — o —o — o —o — o —o — o — */

int factorial(int a)
{ if(a == 0 || a == 1)
return 1;

int i, f;
f = 2;
for(i = 3; i <= a; i++)
{ f = f * i; }

return f;
}

/* —o — o —o — o —o — o —o — o —o — o — */

int main(int argc, char *argv[])
{
int h;
printf(“Teclee el numero de lineas para el triangulo de pascal:\t”);
scanf(“%d”,&h);
printf(“\n”);
//printf(“%d\n”,factorial(h));

int p,n,k,j;
j = h;
for(n = 0; n < h; n++)
{for(k = 0; k < j; k++)
printf(“\t”);
for(p = 0; p <= n; p++)
{printf(“%d\t\t”,(factorial(n)/(factorial(p)*factorial(n-p))));}
printf(“\n”);
j–;}
printf(“\n”);

//system(“PAUSE”);
return 0;
}

Categories: Programacion I

Steps in building Routines

September 12, 2007 Leave a comment

Los pasos para construir una clase son:

* Crear un diseño general para la clase: los diseños de clases tienen muchos problemas de especificaciones. Se definen las responsabilidades específicas de la clase, se determina si la clase depende de otra clase y cuales clases van a depender de esta.

* Construir cada rutina de la clase: Después de que se identifica la rutina principal se debe construir cada rutina. La construcción de las rutinas podría crear problemas al diseño de la clase.

* Revisar y probar la clase: Normalmente cada rutina es probada cuando esta es creada. Después de que la clase es creada en su totalidad, dicha clase debe ser revisada para cualquier problema que no se pueda probar con una rutina individual.

Para la creación de las rutinas se deberán realizar los siguientes pasos:

  • Se diseña la rutina.
  • Se revisa el diseño de la rutina.
  • Se implementa el código de la rutina.
  • Se revisa y se prueba el código de la rutina.

Estos pasos se repiten tantas veces sean necesarias para mejorar la calidad y la eficiencia de las rutinas y por tanto la calidad de las clases mismas.

Porque se deben usar rutinas

Aquí están unas cuantas de las razones por la que se deben utilizar las rutinas.

* Reducen la complejidad: Una de las razones más importantes al crear una rutina es porque se reduce la complejidad del programa. Al utilizar rutinas se esconde información en la cual no hay que pensar, solamente al momento de escribirlas. Después de que estas rutinas están escritas y han sido revisadas no hay que preocuparse por volverlas a leer ni a pensar en ellas ya que es un código aparte y ya han sido probadas hasta alcanzar el funcionamiento adecuado.

* Se evita el duplicar código: Otras de las razones más importantes al crear una rutina es para evitarse el duplicado de código. Al tener el código en una rutina es mas fácil de modificar ya que se encuentra en un solo sitio del programa, en ves de tener el mismo código copiado en varios lugares. Si el código de la rutina esta correcto entonces en todos los sitios que se utilice esa rutina estarán correctos también.

* Limitando los efectos del cambio: Si un código es probable de que se va a cambiar ya sea para mejorarlo o para personificarlo mejor al cliente, pues teniendo rutinas es una forma mas fácil de realizar dichos cambios, ya que se limitan los lugares en donde los cambios se van a efectuar.

* Se mejora la eficiencia: Al tener un código en una sola rutina, esto mejora la eficiencia del programa, ya que se puede optimizar de manera mas fácil y comprensible, lo cual aumenta la eficiencia en cada ves que la rutina sea llamada.

* Código re-usable: Los códigos que se encuentran en rutinas son más fáciles de re-usar y ajustar en programas para ahorrar tiempo y mejorar la calidad.

* Comprensión del código: Las rutinas con nombres bien estructurados mejoran la compresión del código de los programas, ya que una rutina con un buen nombre nos ahorra tiempo y son más fáciles de comprender su utilidad sin necesidad de leer la rutina completa.

Nombres de Rutinas

Una rutina con un nombre bien estructurado es tan importante como el código mismo de la rutina. Los nombres de las rutinas tienden a ser más complicados que los nombres de las variables ya que estos tienen que dar a conocer el código y la utilidad de dicha rutina. No importa que el nombre de la rutina sea amplio, mientras con este se pueda describir bien la rutina.

Categories: Programacion I