Construccion en Colaboracion

INTRODUCCION

De una forma u otra, todas las técnicas de construcción en colaboración son los intentos de formalizar el proceso de mostrar su trabajo a otra persona con el fin de eliminar errores.

1. RESEÑA DE LAS TECNICAS DE DESARROLLO EN COLABORACIÓN

La "Construcción en Colaboración" se refiere a la programación en pares, las inspecciones formales, análisis técnicos informales, y la lectura de documentos, así como otras técnicas en las que los desarrolladores deben de compartir la responsabilidad de la creación de código y otros productos de trabajo.


1.1 Construcción en Colaboración complementa otras técnicas de fortalecimiento de calidad.

El objetivo principal de la construcción en colaboración es la mejora de la calidad del software. El segundo beneficio de la construcción en colaboración es que se reduce el tiempo de desarrollo, que a su vez reduce los costos del mismo.

Los primeros informes sobre la programación en par sugieren que puede lograr un código de nivel de calidad similar al de las inspecciones formales. El desarrollo de código en pares es de un 10 a 25% mas costoso que el desarrollo de una sola persona, pero la reducción en el tiempo de desarrollo es de un 45% aproximadamente, en algunos casos suele ser una gran ventaja sobre el desarrollo de una sola persona.

Los Análisis técnicos se han estudiado mucho más tiempo que la programación en pares, y sus resultados, como se describe en los estudios de casos y en otros lugares, han sido impresionantes:

· IBM encontró que cada hora de la inspección impide cerca de 100 horas de trabajo relacionado con (prueba y corrección de defectos).
· Hewlett-Packard informó de que su programa de inspección ha ahorrado un estimado de $ 21,5 millones por año.

· Raytheon redujo su costo de corrección de defectos (reelaboración) de aproximadamente el 40% del coste total del proyecto a cerca de 20% a través de una iniciativa que se centró en las inspecciones.


Un efecto secundario es que cuando las personas saben que su trabajo será examinado, se dedican a analizar más detenidamente. Así pues, aun cuando las pruebas se realizan de manera eficaz, exámenes u otros tipos de colaboración son necesarios como parte de un programa de calidad.

2. PROGRAMACIÓN EN PAREJA
En esta un programador esta en el teclado y el otro programador observa los errores y piensa estratégicamente acerca de si el código está escrito correctamente.

2.1 Claves para el Éxito

El concepto básico de la programación en pareja es simple, pero su uso, sin embargo, se beneficia de algunas directrices:

· Apoyo a la programación en pareja con una codificación estándar: No será eficaz si las dos personas pasan el tiempo discutiendo sobre el estilo de codificación.

· No dejar que la programación en pareja se convierta solo en observación: La persona sin el teclado debe ser un participante activo en la programación. Esa persona está analizando el código, y debe adelantarse a lo que se codificará, evaluar el diseño, la planificación y la forma de probar el código.

· Alternar las parejas y tareas de trabajo regularmente: el beneficio esta en que hay programadores aprendiendo de las diferentes partes del sistema.

· Alentar a las parejas para que vallan al ritmo de los demás: Uno va demasiado rápido limita el beneficio de contar con opiniones del otro socio.


· Asegúrese de que ambos socios pueden ver el monitor.


· No obligar a trabajar con una persona que no es de su agrado: A veces, conflictos de personalidad, impiden a las personas un trabajo eficaz.

· Evite emparejar todos los novatos: funciona mejor cuando al menos uno de los socios tiene experiencia.

· Asignar un jefe de equipo: Si su equipo quiere hacer 100 por ciento de su programación en pareja, sólo deberá asignar a una persona para coordinar las tareas de trabajo, que se considerará responsables de los resultados, y actuar como punto de contacto para las personas fuera del ámbito del proyecto.


2.2 Beneficios de la Programación en Pareja

· Se elimina un poco el estrés por desarrollo en solitario.

· Se mejora la calidad del código. La legibilidad y comprensibilidad del mismo tiende a aumentar con el nivel del mejor programador en el equipo.

· Se acorta horarios. Pares tienden a escribir código más rápido y con menos errores. El equipo del proyecto dedica menos tiempo al final en la corrección de los defectos del proyecto.

3. LAS INSPECCIONES FORMALES

La inspección es un tipo específico de análisis que ha demostrado ser muy eficaz en la detección de errores y de ser relativamente económico en comparación con los demás.

3.1 Que resultados puedo esperar de las inspecciones?

Las inspecciones normalmente eliminan 70-85% o más de los defectos de un producto.

Los programadores aprenden a mejorar su trabajo a través de la participación en las inspecciones, y estas aumentan la productividad en aproximadamente un 20%.
En un proyecto que utiliza las inspecciones para el diseño del código, las inspecciones se llevarán aproximadamente 10-15 por ciento del presupuesto del proyecto y normalmente reducir el costo general del mismo.

3.2 Funciones durante una Inspección

Una característica fundamental de una inspección es que cada uno de los actores tiene un papel que desempeñar, por ejemplo:

Moderador: es responsable de mantener la inspección en movimiento, a un ritmo que sea lo suficientemente rápido para ser productivas, pero con lentitud suficiente para encontrar la mayoría de los errores posibles.

Autor: La persona que hizo el diseño del código, desarrolla un papel relativamente menor en la inspección. Parte del objetivo de una inspección es para asegurarse de que el código habla por sí mismo.

Evaluador: Es cualquier persona que tenga un interés directo en el código, pero que no es el autor. Su función es encontrar errores.

Anotador: registra los errores que se detecten y los puntos que son asignados durante la reunión de inspección.

La Administración: Incluir la administración en una inspección usualmente no es una buena idea. Sin embargo, la administración tiene derecho a conocer los resultados de una inspección, lo cual se hace por medio de un informe de inspección.

3.3 Procedimiento General para una inspección

Una inspección consta de varias etapas:

Planificación: el autor le da el diseño del código al moderador. Este decide quien va a examinar el material y cuando y donde va a ocurrir la inspección, entonces le da un checklist para centrar puntos importantes.

Visión General: Cuando los encargados de revisión no están familiarizados con los proyectos en los que están trabajando, el autor puede pasar hasta una hora describiendo la técnica entorno la cual se ha hecho el diseño. Aunque el diseño del código debe hablar por si mismo, no la visión general.

Preparación: Cada examinador trabaja solo para analizar el diseño del código en la búsqueda de errores. Los examinadores utilizan el checklist para estimular y orientar su análisis.

Reunión de Inspección: El moderador elige a alguien que no sea el autor para leer el código. El encargado de registrar los errores, muestra sus registros y la discusión de un error se detiene tan pronto como se le reconoce como un error. No discutir soluciones durante la reunión. El grupo debe permanecer centrado en la identificación de los defectos.

Informe del grupo de Inspección: Este es emitido por el moderador luego de la reunión de inspección, listando cada error, incluyendo su tipo y gravedad. Esto sirve para asegurarse que todos los errores serán corregidos.

Reelaboración: el moderador asigna errores a alguien, usualmente el autor, para que los corrija.

Seguimiento: El moderador es el encargado de velar por que la modificación de todo lo asignado durante la inspección se lleve a cabo.

Reunión de Tercera Hora: Esta se realiza después que la inspección oficial ha terminado, para permitir que las partes interesadas tengan la oportunidad de debatir soluciones.


3.4 Ajuste de la Inspección

Mientras realiza las inspecciones, podrá ver que ciertos tipos de errores se producen con más frecuencia que otros. Crear una lista de verificación que llame la atención de los examinadores sobre los tipos de errores encontrados. Con el tiempo, encontrará tipos de errores que no se encuentran en la lista de control; y deberá de añadirlos.

Es posible que algunos errores en la lista de verificación inicial dejen de producirse; entonces elimínelos. Después de unas cuantas inspecciones, su organización tendrá una lista de comprobación para las inspecciones personalizada a sus necesidades.



4. OTRAS TÉCNICAS DE DESARROLLO EN COLABORACIÓN

Entre las demás técnicas tenemos Paseo, Lectura de Código y Dog and Pony Shows.

4.1 Walk-Throughs

Este es un popular tipo de análisis. Es un término que ha sido muy vagamente definido por lo que resulta un poco difícil decir lo que es. Pero ciertamente, consiste en dos o más personas discutiendo el diseño del código. Esta puede ser una reunión tanto formal como informal.

Algunas de las cosas que todos los walk-thoughs tienen en común:

· Son moderados por el autor del código bajo revisión.
· Se enfoca en cuestiones técnicas.
· Todos los participantes se preparan para la reunión leyendo el código en busca de errores.
· Tiene una duración de 30 a 60 minutos.
· Se hace énfasis en la detección de errores, no en la corrección.
· Su concepto es flexible por lo que puede ser adaptado a las necesidades específicas de quienes lo aplican.


4.1.1 Que resultados puedo esperar de Walk-Throughs?

Si esta es usada inteligentemente y con disciplina, puede producir resultados similares a los de las inspecciones formales.

Si se tiene un grupo grande de examinadores de código, la opción preferible seria walk-throughs porque proporciona más puntos de vista sobre los temas en discusión. Los roles en las inspecciones son mas formales y las personas necesitan tener experiencia para ser efectivos.

4.2 Lectura de Código

En esta técnica usted lee el código fuente en busca de errores. Además comente y califica aspectos del código como diseño, estilo, legibilidad, mantenibilidad y eficiencia.

La lectura de código consiste en dos o mas personas leyendo el código por separados y luego se reúnen con el autor para discutir sobre los errores encontrados.

La lectura de código funciona de la siguiente manera:

· El autor proporciona el código a los analistas.
· Dos o mas personas leen el código por separado. Aproximadamente 1000 líneas por día.
· Cuando los analistas terminan convocan a reunión con el autor del código. Esta debe durar aproximadamente de 1 a 2 horas y discuten sobre los problemas encontrados.
· El autor soluciona dichos problemas.


La diferencia entre esta y las inspecciones y walk-throughs es que esta basada en la lectura individual de código mas que en la misma reunión.

4.3 Dog and Pony Shows

Son evaluaciones en las que un producto de software es demostrado a un cliente. En esta el objetivo es demostrar a un cliente que el proyecto esta bien, por lo que es más bien un análisis de gestión que un análisis técnico.

5. REFERENCIAS

[1] Construcción en Colaboración (cap.21) Code Complete 2da ed.
[2] The Software-Quality landscape (cap. 20) Code Complete
[3] Developer Testing (cap. 22). Code Complete
[4] Prerequisites to Construction (cap. 3 y 4) Code Complete.

Programa Bancario

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

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

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

int Busqueda(Client clientes[], int cuentas)
{ 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, cuentas);
if(e==-1)
{cout<<”\n ** No se encuentra el cliente **\n”;
return -1;}
cout<<” Cuenta #:\t”<cout<<” Balance:\t$”<return e;
}

void Print(Client clientes[], int cuentas)
{
cout<<”\n Nombre:\t”<cout<<” Apellido:\t”<cout<<” Cuenta #:\t”<cout<<” Balance:\t$”<}

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

while(!0){
cout<<”\n\n\t1)Nuevo cliente\n\t2)Buscar cliente\n\t0)Salir\n”;
cout<<”>”;
cin>>x;

if(x==0)
break;

switch(x){
case (1):
id(clientes, cuentas);
cuentas++;
break;
case (2):
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:
cout << “\n Cantidad a depositar: “;
cin >> money;
clientes[e].balance += money;
Print(clientes,e);
break;
case 2:
cout << “\n Cantidad a retirar: “;
cin >> money;
if(money > clientes[e].balance)
{ cout << “\n ** No hay balance suficiente **\n”;
break; }
clientes[e].balance -= money;
Print(clientes,e);
break;
case 0:
break;
default:
cout << “\n\n ** Opcion no valida \n**”;
}
break;
default:
cout << “\n\n Opcion No Valida\n”;
break; } }
return EXIT_SUCCESS;
}

Programa de Tickets

#include
#include

using namespace std;

int Venta(int sits[],int precio[], int x, int& venta)
{
int cantidad, total;
cout<<”\n Cantidad de taquillas: “; cin>>cantidad;
if ( cantidad > sits[x])
{ cout<<”\n ** No hay suficientes taquillas **\n”; return -1; } sits[x] -= cantidad; total = cantidad * precio[x]; venta += total; return cantidad; } int main(int argc, char *argv[]) { int sits[4]; int precio[4]; int e, ventas = 0; int x; sits[0] = 50; sits[1] = 100; sits[2] = 250; sits[3] = 65; precio[0] = 1500; precio[1] = 900; precio[2] = 500; precio[3] = 100; while(!0){ cout<<”\n Asientos Disponibles/Precios\n\n”; cout<<” V.I.P.:\t”<<>”;
cin >> x;

if(x == 0)
break;

switch(x){
case (1):
e=Venta(sits, precio, 0, ventas);
if (e==-1)
break;
cout<<”\n “<break;
case (2):
e=Venta(sits, precio, 1, ventas);
if (e==-1)
break;
cout<<”\n “<break;
case (3):
e=Venta(sits, precio, 2, ventas);
if ( e==-1)
break;
cout<<”\n “<break;
case (4):
e=Venta(sits, precio, 3, ventas);
if ( e == -1)
break;
cout<<”\n “<break;
default:
cout<<”\n\n Opcion No Valida\n”;
break; }
}
return EXIT_SUCCESS;
}

Programa de Calificaciones

#include
#include
#include
using namespace std;
typedef struct {string nombre; string apellido; int Esp; int Mat; int Soc; int Cn; int Ing; int Prog;} 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){int e;string nombre, apellido;cout<<”\n Nombre:\t”;cin>>nombre;cout<<” Apellido:\t”;cin>>apellido;e=Buscar(nombre, apellido, Est, y);if(e>=0){cout<<”\n ** Este alumno ya existe **\n”;return 0;}Est[y].nombre = nombre;Est[y].apellido = apellido;y++;return 1;}
int InsNota (string nombre, string apellido, Alumno Est[], int y){int e;e=Buscar(nombre,apellido,Est,y);if (e==-1){cout<<”\n** No se encuentra el estudiante. **\n\n\n”;return 1;}cout<<”\nInserte la nota de Espanol:”;cin>>Est[e].Esp;cout<<”Inserte la nota de Matematicas:”;cin>>Est[e].Mat;cout<<”Inserte la nota de Ciencias Sociales:”;cin>>Est[e].Soc;cout<<”Inserte la nota de Ciencias Naturales:”;cin>>Est[e].Cn;cout<<”Inserte la nota de Ingles:”;cin>>Est[e].Ing;cout<<”Inserte la nota de Programacion:”;cin>>Est[e].Prog;return 0;}int Imp (string nombre, string apellido, Alumno Est[], int y){int e;e=Buscar(nombre,apellido,Est,y);if (e==-1){cout<<”\n ** No se encuentra el estudiante. **\n”;return 1;}//cout<<”\nNombre: “<int main(int argc, char *argv[]){Alumno Est[1000];
string nombre,apellido;int x=!0,y=0;while (x!=0){cout<<”\n\n Elija la opcion deseada:\n\n\t1)Nuevo Alumno\n\t2)Buscar Alumno\n\t3)Ingreso de notas\n\t0)Salir\n”;cout<<”>”;cin>>x;
switch(x){case (1):RegAlum(Est, y);break;case (2):cout<<”Ingrese el Nombre del Estudiante:”;cin>>nombre;cout<<”Ingrese el Apellido del Estudiante:”;cin>>apellido;Imp (nombre,apellido,Est,y);break;case (3):cout<<”Ingrese el Nombre del Estudiante:”;cin>>nombre;cout<<”Ingrese el Apellido del Estudiante:”;cin>>apellido;InsNota (nombre,apellido,Est,y);break;default: cout<<”** Opcion Incorrecta **”;break;
}}return EXIT_SUCCESS;}

1ER PRUEBIN

DISEÑE ALGORITMO PARA LA SOLUCION DE CADA UNO DE LOS SIGUIENTES PROBLEMAS:

FACTORIAL:

int i, num;
long fac;
printf("\n INgrese numero: ");
scanf("%d", &num);

{ fac = 1;
for (i=1; i<=num; i++)
fac *= i;
printf ("factorial es: %d",fac);

POTENCIACION:

int x,n,R;
printf("escriba el numero k kiere elevar\n");
scanf("%d",&x);
printf("escriba la potencia\n");
scanf("%d",&n);
R= pow(x,n);
printf("\n\t%d\n",R);

SUMA DE UNA SERIE DE NUMEROS

int i,n,s;
s=0;
printf("dame n:");
scanf("%d",&n);
for (i=1;i<=n;i++)
{
s=s+i; }
printf("la sumatoria es:%d\n",s);

MINIMO COMUN MULTIPLO

int a, b, p, q, r, mcd, mcm;
printf("\nDigite dos números enteros y positivos: ");
scanf("%d %d", &a, &b);
if (a < b){ p = b;q = a; }
else{ p = a;q = b; }
r = p%q;
while ( r != 0 )
{ p = q;q = r;r = p%q; }
mcd = q;mcm = a*b/mcd;
printf("\n\tmcm( %d, %d) = %d", a, b, mcm);

ETAPAS PROCESO DE COMPILACION

ABSTRACTO
Este documento contiene información acerca del proceso de compilación y sus diferentes fases en el proceso de paso del código fuente al código maquina entendible y ejecutable por el computador. Podrán ver gráficos ilustrativos de las fases para mayor entendimiento. Palabras Claves Programa, código fuente, código maquina, compilación, linkado.

1. INTRODUCCION
Programa: Algoritmo (secuencia no ambigua, finita y ordenada de instrucciones para la resolución de un determinado problema) traducido a un lenguaje de programación, de modo que un ordenador es capaz de ejecutarlo. Programación: Elaboración de un programa de manera que éste sea: − Correcto Un programa será correcto si hace lo que debe hacer, de modo que se deben especificar de manera muy clara cuáles son los datos sobre los que se trabajarán y lo que se debe hacer con ellos. Todo debe ser documentado y probado antes de desarrollarlo. − Eficiente Debe consumir la menor cantidad de recursos (tiempo y/o memoria) posible. − Claro Es muy importante la claridad y legibilidad de todo programa, ya que facilitará al máximo la tarea de mantenimiento posterior del software. − Modular Los programas suelen subdividirse en subprogramas (módulos), para reducir la complejidad de aquella parte que se está implementando y facilitar la reutilización de código. Para la elaboración de un programa hay que distinguir entre las siguientes dos fases: − Fase de compilación y linkado (link, montado o enlace) − Fase de ejecución de un programa

2. FASE DE COMPILACIÓN Y LINKADO (LINK, MONTADO O ENLACE) Un programa escrito en un lenguaje de alto nivel, no puede ser ejecutado directamente por un ordenador, sino que debe ser traducido a lenguaje máquina. Las etapas por las que debe pasar un programa escrito en un lenguaje de programación, hasta poder ser ejecutable son:




Figura 1. Proceso de transformación de un programa fuente a un programa ejecutable.

Programa fuente: Programa escrito en un lenguaje de alto nivel (texto ordinario que contiene las sentencias del programa en un lenguaje de programación). Necesita ser traducido a código máquina para poder ser ejecutado.

Compilador: Programa encargado de traducir los programas fuentes escritos en un lenguaje de alto nivel a lenguaje máquina y de comprobar que las llamadas a las funciones de librería se realizan correctamente.

Programa (o código) objeto: Es el programa fuente traducido (por el compilador) a código máquina. Aún no es directamente ejecutable.

Programa Ejecutable: Traducción completa a código máquina, realizada por el enlazador, del programa fuente
y que ya es directamente ejecutable.

Linker (montador o enlazador): Es el programa encargado de insertar al programa objeto el código máquina de las funciones de las librerías (archivos de biblioteca) usadas en el programa y realizar el proceso de montaje, que producirá un programa ejecutable .exe. Las librerias son una colección de código (funciones) ya programado y traducido a código máquina, listo para utilizar en un programa y que facilita la labor del programador.

Como cada lenguaje de programación tiene unas reglas especiales (sintaxis) debe existir un compilador específico para cada lenguaje de programación.

Si el programa fuente es sintácticamente correcto, el compilador generará el código objeto, en caso contrario mostrará una lista con los errores encontrados, no generándose ningún programa objeto, para que procedamos a su depuración Los compiladores emiten mensajes de error o de advertencia durante las fases de compilación, de enlace o de ejecución de un programa:

• Los errores en tiempo de compilación son los que se producen antes de la ejecución del programa, durante el proceso de compilación del programa.

• Los errores en tiempo de ejecución son los que se producen durante la ejecución del programa. Son los más difíciles de encontrar, no son detectados por el compilador, ya que son errores de lógica, no de sintaxis.

Aunque al compilar un programa no de errores, el programa puede funcionar incorrectamente y/o a dar errores durante su ejecución. Por ejemplo:

• Un programa puede producir resultados erróneos, al equivocarnos (errores lógicos) al programar el algoritmo (sumar en vez de restar, etc.).

• Un programa puede interrumpirse bruscamente, por ejemplo si tenemos que hacer una división y el divisor es cero, etc.

Los errores que se pueden producir en la fase de compilación son:
− Errores fatales: Son raros. Indican errores internos del compilador.
Cuando ocurren la compilación se detiene inmediatamente.

− Errores de sintaxis: Son los errores típicos de sintaxis. No detienen la compilación sino que al finalizar ésta se mostrará la lista con todos los errores encontrados. Algunos errores suelen ser consecuencia de otros cometidos con anterioridad. Con este tipo de errores no se puede obtener un programa objeto y por lo tanto tampoco el ejecutable.

− Advertencias o avisos (warnings): Indican que hay líneas de código sospechosas que a pesar de no infringir ninguna regla sintáctica, el compilador las encuentra susceptibles de provocar un error. Cuando se detecta un warning la compilación no se detiene. Si en un programa fuente sólo se detectan warnings sí que se podrá obtener un programa objeto, que tras el linkado dará lugar a un programa ejecutable.

Con respecto a los errores en tiempo de ejecución, encontrar la causa que los provoca es una labor en ocasiones complicada, razón por la cual los EID
(Entornos Integrados de Desarrollo, p.ej. DevC++) nos proporcionan una herramienta llamada Depurador que nos ayuda a encontrar los errores lógicos y demás errores producidos en tiempo de ejecución.

Un depurador (debugger), es un programa diseñado específicamente para la detección, verificación y corrección de errores. Los depuradores nos permiten trazar el programa (ejecutarlo sentencia a sentencia) y visualizar el contenido de las variables y direcciones de memoria durante la ejecución del programa.

Además permiten alterar el flujo de ejecución del mismo, cambiar los valores de las variables e introducir puntos de parada.
1. EL COMPILADOR DE C. CARACTERÍSTICAS GENERALES
El lenguaje C es un lenguaje muy potente y eficiente de nivel medio: combina elementos de lenguajes de alto nivel con la funcionalidad del lenguaje ensamblador. Es adecuado para la programación de sistemas.

♦ Es un lenguaje de propósito general (puede utilizarse para desarrollar sistemas operativos, gestores de bases de datos, etc).

♦ El código de C es muy portable: se puede adaptar el software escrito para un tipo de computadora a otra computadora sin hacer muchos cambios.

♦ El lenguaje C es un lenguaje estructurado: permite seccionar y esconder (mediante subrutinas y variables locales) del resto del programa toda la información e instrucciones necesarias para realizar una determinada tarea.

♦ El lenguaje C sólo tiene 32 palabras clave, (BASIC por ejemplo tiene 159).

♦ Suele incluir potentes librerías de funciones que aumentan su potencia.

♦ El lenguaje C es compilado, no interpretado. Un intérprete lee el código fuente de un programa línea a línea y las traduce online para que la CPU las pueda interpretar, pero no genera ningún programa objeto. Un compilador lee el programa entero, lo traduce y genera un código objeto directamente ejecutable y entendible por el microprocesador.

2. REFERENCIAS
[1] http://laurel.datsi.fi.upm.es/~rpons/personal/trabajos/curso_c/node87.html
[2] http://www.uhu.es/04004/material/Transparencias3.pdf

PERMUTACIONES

1. INTRODUCCION
Antiguamente, se definía una permutación así:
Sea un número n de objetos, (n>1), alineados en
una mesa con el fin de poder atribuir a cada cual
su rango: el objeto más a la izquierda es el
primero, el que sigue el segundo y así
sucesivamente. Ahora se mezclan los objetos y se
les vuelven a colocar en una fila, en cualquier
orden. Se dice que se han permutado los objetos,
o, lo que viene a ser lo mismo, los números de 1 a
n.
Si el objeto que se encuentra actualmente a la
izquierda era antes el quinto de la fila, si el que se
encuentra a su derecha era el séptimo ... y el que
está al final era el segundo ... entonces la actual
permutación está caracterizada por los serie de
números ( 5, 7, ..., 2).
La definición moderna de una permutación ya no
hace referencia al mundo real, y prescinde de los
objetos.
Para conocer la permutación, sólo se necesita
conocer la serie de números (5, 7, ..., 2) en el
ejemplo. Se dice que 5 es la imagen de 1 por la
permutación, 7 es la imagen de 2, ...y 2 es la
imagen de n. De este punto de vista, una
permutación es una aplicación biyectiva de
{1,...,n} hacia {1,...,n}. Es biyectiva porque a cada
posición anterior de un objeto corresponde una
única posición actual.
Las Técnicas de conteo son importantes en matemáticas y las
ciencias de la computación, particularmente en el análisis de
algoritmos.
Una permutación del conjunto {1, . . . , n} es una lista de
longitud n sin repetición formada por sus elementos; el conjunto
de todas ellas lo llamaremos
Perm({1, . . . , n}) = { n-listas sin repetición formadas con los
símbolos {1, . . . , n}} .
Sabemos, por supuesto, que hay n! de ellas. En los términos en
que las estamos definiendo, cada permutación es una
(re)ordenación de los elementos de
{1, . . . , n}.
Ya vimos, en el ejemplo 2.2.5, que podemos entender también
una permutación de un conjunto finito X como una aplicación
biyectiva de X en X. Como siempre, para simplificar la notación,
supondremos que X = {1, . . . , n}.
Para exhibir una permutación podemos escribir la lista
correspondiente,
(2, 7, 5, 1, . . . , 6) (permutación como lista) o bien utilizar la
siguiente notación:
)
1 2 3 4 . . . n
2 7 5 1 . . . 6


(permutación como aplicación biyectiva) que nos permite
reconocer rápidamente la imagen de cada elemento de {1, . . . ,
n} por la permutación. Es decir, identificamos la lista (2, 7, 5, 1,
. . . , 6) con la aplicación biyectiva que lleva el 1 en el 2, el 2 en
el 7, el 3 en el 5, etc.
Unas permutaciones especiales son los desbarajustes, las
aplicaciones biyectivas que no fijan elemento alguno (el símbolo
j nunca va al j, para cada j = 1, . . . , n). En términos de listas,
son las n-listas tales que, para cada j = 1, . . . , n, el símbolo j no
ocupa la posición j de la lista. Pronto calcularemos cuantos de
estos desbarajustes hay. Otras permutaciones que aparecerán mas
adelante son las trasposiciones, cuyo efecto es el de
intercambiar las posiciones de dos elementos (y fijar los n − 2
restantes).
Para lo que sigue, es conveniente tener presente la definición de
permutación como aplicación biyectiva del conjunto en si mismo.
Sean, por ejemplo, las dos siguientes permutaciones del conjunto
X = {1, 2, 3, 4, 5}:
f : (1, 3, 2, 5, 4) =
)
1 2 3 4 5
1 3 2 5 4
g : (2, 1, 3, 5, 4) =
)
1 2 3 4 5
2 1 3 5 4
.
La permutación g es una aplicación del conjunto {1, 2, 3, 4, 5} en
si mismo que lleva, por ejemplo, el elemento 1 en el 2: g(1) = 2.
Pero también f lo es, y observemos que lleva el 2 en el 3, f(2) =
3. Así que si primero hacemos actuar g y luego f, entonces, por
ejemplo, el elemento 1 acaba yendo al 3.
2. PERMUTACIONES SIN REPETICIÓN
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á:
Ponemos como ejemplo las siguientes letras: aei
2.1.1 El número de permutaciones sin
repetición de esos 3 elementos es 6 y esas
permutaciones son:
aei
aie
eai
eia
iae
iea
3. PERMUTACIONES CON REPETICIÓ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á:
Ahora ponemos como ejemplo las siguientes letras: aea
3.1.1 El número de permutaciones con
repetición de esos 3 elementos tomados de
2 en 2 y de 1 en 1 es 3 y esas permutaciones
son:
aea
aae
eaa


4. REFERENCIAS
[1] Estructuras de las Matematicas Discretas para la
Computacion. Kolman, Busby, Ross.. Pag. 75
[2] http://club.telepolis.com/ildearanda/combina/per_marco.htm
[3] http://www.uam.es/personal_pdi/ciencias/gallardo/capitulo3
b_2004_2005.pdf

TIPOS DE VARIABLES POR SU ARQUITECTURA

data type ------------32 size (bits)--------- 64 size (bits)

char ---------------------8---------------------- 8

short-------------------- 16-------------------- 16

int ----------------------32-------------------- 32

long --------------------32--------------------- 64

float --------------------32--------------------- 32

double -----------------64---------------------- 64

long double ------------128 ---------------------128