#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;
}

#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;
}

#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;
}

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.

#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;
}

* 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.

* Evitar escribir con elementos de algún lenguaje de programación.

* Escribir el pseudo código con un bajo pero buen nivel de comprensión.

Después de escribir el pseudo código, bajo este se escriben el código del programa en el lenguaje de programación que se quiera, después el pseudo código se puede utilizar como documentación de dicho programa. De esta forma los comentarios serán precisos y suficientemente claros para explicar la funcionalidad del programa.

Ventajas del pseudo código

Entre las ventajas que nos proporciona escribir en pseudo código se encuentran las siguientes:

* Revisión: El pseudo código nos facilita las revisiones. Las revisiones de diseño se hacen más fáciles ya que están escritas en un lenguaje ordinario y fácil de comprender.

* Mejor codificación: El pseudo código hace que la codificación sea mas fácil y eficiente, ya que comienza desde un nivel alto hasta el nivel del lenguaje utilizado, haciendo que los errores sean mas claros y fáciles de corregir.

* Comentarios: El pseudo código ahorra tiempo y nos facilita comentar el código de la aplicación. Ya que el propio pseudo código se convierte en los comentarios.

* Diseño: Con los pseudo códigos el diseño queda como documentación y hace mas fácil de mantener la estructura y de no despistar el código de donde debería ir.

Opciones al PPP

Además del pseudo codigo (PPP) sus singlas en ingles por Pseudocode Programming Process se encuentran las siguientes opciones:

* Test-first development: Como su nombre lo dice, es una tecnica de desarrollo en la cual se prueba primero y después se codifica lo necesario para pasar la prueba satisfactoriamente.

* Refactoring: Con esta técnica se busca que el código sea mejorado sin cambiar el comportamiento del mismo. Por ejemplo, se puede utilizar esta técnica cuando el código de una rutina es muy largo o cuando hay se repiten pedazos de códigos.

* Design by contract: Es una técnica en la cual se busca una meta en común, en donde se utilizan precondiciones y poscondiciones.

* Hacking: Hay programadores que prefieren comenzar a escribir el código en ves de planificarlo. Esta técnica trae problemas cuando al programador se les acaban las ideas, el código se complica o se olvida escribir algún pedazo de código. En todos los casos la programación por pseudo código es más satisfactoria y eficiente.

Las permutaciones sin repetición de n elementos se definen como las distintas formas de ordenar todos esos elementos distintos, por lo que la única diferencia entre ellas es el orden de colocación de sus elementos.

El número de estas permutaciones será:

Pn = n!
Llamamos a las permutaciones con repetición de n elementos tomados de a en a, de b en b, de c en c, etc, cuando en los n elementos existen elementos repetidos (un elemento aparece a veces, otro b veces, otro c veces, etc) verificándose que a+b+c+…=n.

El número de estas permutaciones será:

PRn = n!/a!b!c!

Ejemplo de permutaciones

Aquí un ejemplo de permutaciones sin repetición utilizando 3 elementos, en este caso se utilizaran las letras “a” “b” “c”.

El número de permutaciones sin repetición de esos 3 elementos es 6:

X = 3!

X = 3*2*1

X = 6

Y esas permutaciones son:

abc             acb
bac             bca
cab             cba

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

/* Funcion que da valores al arreglo del 1 hasta el numero de letras que se hayan ingresado */

int valor(int * p, int N)
{ int i;

for(i = 0; i < N; i++)
{ p[i] = i+1; }

return 1; }

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

/* Saca el factorial de un numero */

int factorial(int N)
{ int i, f;
f = 1;

for(i = 2; i < N+1; i++)
{ f = f * i; }

return f; }

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

/* Funcion que busca el factorial de un arreglo */

int multi(int * p, int N)
{ int i, m;
m =1;

for(i = 0; i < N; i++)
{ m = m * p[i]; }

return m; }

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

int main(int argc, char *argv[])
{
if(argc == 1)
{printf(“\n Escriba una palabra \n”);
return 0; }

int c = 0;
int s = strlen(argv[1]);
int i, k;

int * X;
X = (int*) calloc (s,sizeof(int));

valor(X, s);

printf(“\n”);

while(c < factorial(s))
{ if(multi(X,s) == factorial(s))
{ k = 0;
printf(“\t”);
while(k < s)
{printf(“%c”,argv[1][X[k]-1]);
k++;
}
c++;
}

i = s;
X[s-1] = X[s-1] + 9;
while(i > 0)
{ if(X[i-1] > 10)
{ X[i-1] = X[i-1] – 10;
X[i-2] = X[i-2] + 1;
}
i–;
}
}

printf(“\n”);

free(X);

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