Logica Computacional

Practica 10: Ejercicios con Arreglos unidimensionales.

2007-09-24T20:36:00.000-07:00

Materia: Lógica Computacional.
Profesor: Lic. Salomón Aquino.

I. Objetivo. Al finalizar la práctica el estudiante será capaz de:
• Definir estructuras de datos y arreglos.
• Utilizar arreglos en una dimensión para resolver problemas.
II. Introducción Teórica.
Los Arreglos (Vectores o Array)
Un array (lista o tabla9 es una secuencia de datos del mismo tipo. Los datos se llaman elementos del array y se numeran consecutivamente 0, 1, 2, 3, ,, etc. Estos números se denominan valores índice o subíndice del array. El tipo de elementos almacenados en el array pueden ser cualquier tipo de dato de C, incluyendo estructuras definidas por el usuario.
Entonces, podemos entender los arrays (también conocidos como arreglos o formaciones) como variables que contienen diferentes tipos de datos homogéneos. Se puede acceder a cada elemento de datos individual de la variable mediante un subíndice, o índice. En los lenguajes C y C++, un array no se corresponde con un tipo de dato estándar; en su lugar, se trata de un tipo agregado que se obtiene a partir de otros tipos de datos. Es posible tener un array de cualquier cosa: caracteres, enteros, números en coma flotante, arrays, etc.
Un array se declara de modo similar a otros tipos de datos, excepto que se debe indicar al compilador el tamaño o longitud del array. Para indicar al compilador el tamaño o longitud del array se debe hacer seguir al nombre, el tamaño encerrado entre corchetes.
Los arrays tienen cuatro propiedades básicas:
• Los elementos individuales de datos de un array se denominan elementos.
• Todos los elementos deben ser del mismo tipo de dato.
• Todos los elementos se almacenan en posiciones contiguas de la memoria de la computadora y el subíndice (o índice) del primer elemento es cero.
• El nombre de un array es un valor constante que representa la dirección del primer elemento del array.
Para acceder a un elemento especifico del array, se utiliza el nombre de éste seguido por uno o más “índices” (donde cada uno representa una dimensión del arreglo o array) encerrado entre corchetes. Supongamos que tenemos un arreglo unidimensional llamado X con un tamaño de “n” elementos, su esquema grafico es el siguiente:

Como puede verse en el esquema, aunque el arreglo es de “n” elementos, en realidad tienen “n-1” elementos porque comienzan a enumerarse desde cero.
En términos generales para definir un array se especifica el tipo de almacenamiento (atributo opcional), el tipo de datos, el identificador y entre corchetes el tamaño del arreglo. Abajo se muestra algunos ejemplos de definición de arreglos:

a) int num[100]; (un array de 100 enteros)
b) char apellido[25]; (un array de 25 caracteres)
c) float prom[30]; (un array de 30 coma flotante)
d) char contrasena[16]; (un array de 16 caracteres)

La necesidad de definir arrays en función de constantes
A veces es conveniente definir el tamaño de un array en términos de una constante, en lugar de estar especificando una cantidad entera fija. Esto se realiza por facilidad de mantenimiento. Por ejemplo, suponga que tenemos un programa (con 350 líneas de código) donde se halle un array de 20 items, y a lo largo del programa se hace referencia unas 12 veces al arreglo, y supongamos también que se necesita cambiar el tamaño del arreglo. Sin usar la constante se tendría que revisar todo el programa para localizar las líneas de código y efectuar el cambio al nuevo tamaño, en cambio con el uso de constantes sólo se le cambia el tamaño a la misma y el problema esta resuelto. La definición de un array a través de una constante se muestra en el siguiente ejemplo:
# include stdio.h>
# include stdlib.h>
/* Definición de la constante */
#define tamano 20
main()
{
/* Utilización de la constante para definir la dimensión del arreglo */
int promedios[tamano];
/* Leer valores utilizando la variable i como contador dentro del ciclo FOR y ++i como acumulador*/
for (i=0; i < tamano; ++i)
scanf(“%d”,&promedios[i]);
.....
.....
}
La utilización de constantes definidas garantiza que las siguientes referencias al array no sobrepasen el tamaño definido para el mismo.
C no comprueba que los índices del array están dentro del rango definido.

Inicialización de arreglos
En ciertas circunstancias puede ser necesario darle valores iniciales a los arreglos, para ello basta con colocar entre llaves el conjunto de valores deseados separados por comas y en el orden requerido. A continuación se muestran algunos ejemplos:
a) int cant[6]={12,-3,0,15,8};
b) double DesvTipica[8]={0.23, 3.1416, -0.5, 2.16789, -56.78, 25, 0.15, -14 };
c) char meses[12]={‘E’, ‘F’, ‘M’, ‘A’, ‘M’, ‘J’, ‘J’, ‘A’, ‘S’, ‘O’, ‘N’, ‘D’};

Para el caso del arreglo “cant” es como tener:
Cant[0]=12
Cant[1]= -3
Cant[2]=0
Cant[3]=15
Cant[4]=8

Cuando los elementos del arreglo no tienen asignados valores iniciales explícitos, éstos son puestos a cero, a continuación tenemos un ejemplo:
int edades[8]={25,13,18};

El resultado de la asignación seria el siguiente:
Edades[0]=25;
Edades[1]=13;
Edades[2]=18;
Edades[3]=0;
Edades[4]=0;
Edades[5]=0;
Edades[6]=0;
Edades[7]=0;

Este método de inicializar arrays mediante valores constantes después de su definición, es adecuado cuando el número de elementos del arreglo es pequeño.
Una nota interesante en cuanto a la inicialización de arreglos, es que el tamaño no necesita ser indicado explícitamente. Con los arrays numéricos el tamaño será fijado igual al número de valores incluidos. En cuanto a las cadenas, el tamaño se fijará igual al número de caracteres del string o cadena mas uno (el carácter nulo “\0”).
C puede dejar los corchetes vacíos, sólo cuando se asignan valores al array, tal como
int cuenta[ ] = { 15, 25, -45 , 0 , 50 };
char c[ ] = { ‘L’, ‘u’, ‘i’, ‘s’ }; /* declara un array de 4 elementos */
El compilador asigna automáticamente cinco elementos a cuenta.
Otros ejemplos:
a) Int porcent[ ]={8, 6, 10, -15, 23};
b) Char mes[ ]=”octubre”;
que vienen siendo equivalente a:

Porcent[0]=8;
porcent[1]=6;
porcent[2]=10;
porcent[3]= -15;
porcent[4]=23;

mes[0]=‘o’;
mes[1]=‘c’;
mes[2]=‘t’;
mes[3]=‘u’;
mes[4]=‘b’;
mes[5]=‘r’;
mes[6]=‘e’;
mes[7]=‘\0’

Ejemplo 1:
Elabore un programa que permita leer una lista de números en un arreglo, calcule la suma, promedio, cuadrado , cubo y desviación estándar de los mismos:
#include stdio.h>
#include stdlib.h>
#include conio.h>
#include math.h>
#define tam 4
/* programa para calcular la suma, promedio, cuadrado, cubo y desviación
estandar de una serie de números */
main ( )
{
double vector[tam],cuadrado, cubo;
float prom, desv,suma=0;
int i, j;

system("cls" );
printf ("PROGRAMA PARA CALCULAR \n");
printf(" PROMEDIO, SUMA, CUADRADO, CUBO Y DESV. EST.\n\n") ;
//Captura de valores y suma de los mismos
for(i = 0 ; i < tam ; ++i)
{
printf ("num [%d] = " , i) ;
scanf ("%lf" , &vector[i]) ;
suma+= vector[i] ;
}
prom = suma / tam ;
printf (" \n El promedio de los numeros es: %4.2f\n ", prom) ;
//Calculo e impresión de cuadrado, cubo y desviación estandar
printf(" \n \n NUMERO CUADRADO CUBO DESV. EST.\n");
for( i = 0 ; i < tam ; ++i )
{
cuadrado = vector[i] * vector[i] ;
cubo = pow (vector[i], 3) ;
desv = vector [i] - prom ;
printf ("%.2lf", vector[i] ) ;
printf (" \t%.2lf", cuadrado) ;
printf (" \t%.2lf", cubo) ;
printf (" \t%.2f\n", desv) ;
}
system("pause");
return(0);
}

Nota que los valores fueron declarados de tipo double no enteros, por el tamaño de los valores que se generan en los cálculos.

Ejemplo 2:
El siguiente programa lee 5 valores de teclado y los guarda en un arreglo a. Luego los escribe.

#include stdio.h>
#include stdlib.h>
main()
{
int a[5],i,num;
for(i=0; i<5;i++){
printf("Digite el numero:\n");
scanf("%d",&num);
a[i]=num;
}

printf("\nEscribiendo el arreglo con los datos leidos:\n\n");
for(i=0; i<5;i++){
printf("a[%d]= %d\n\n",i,a[i]);
}
system("pause");
return 0;
}

Ejemplo 3:
El siguiente programa, pide 5 numeros y calcula los cubos de ellos, los cuales son guardados en un arreglo y son desplegados.

#include stdio.h>
#include stdlib.h>
#include math.h>
main()
{
int i;
double a[5], num;
for (i=0; i<5; i++)
{
printf("\n Digite numero:");
scanf("%lf", &num);
a[i]=num;
}
printf("_________________________________________\n");
printf("Los cubos de los numeros leidos son:\n");
for (i=0; i<5; i++){
a[i]=pow(a[i],3);
printf("%.0lf\n",a[i]);
}
printf("\n");
system("pause");
return 0;
}

EJERCICIOS:

Ejercicio 1:
Digite, compile y ejecute el siguiente programa.
#include stdio.h>
#include stdlib.h>
main()
{
int a,b=0;
int c[10]={1,2,3,4,5,6,7,8,9,0};
for (a=0;a<10;++a)
if ((c[a]%2)==0) b+=c[a];
printf("%d\n",b);
system(“pause”);
return 0;
}

¿Qué hace el programa? __________________________________________
_______________________________________________________________
Cuál es la salida? _______

Ejercicio 2:
Digite, compile y ejecute el siguiente programa.
#include stdio.h>
#include stdlib.h>
main()
{
int a,b=0;
int c[10]={1,2,3,4,5,6,7,8,9,0};
for (a=0;a<10;++a)
if ((a%2)==0)b+=c[a];
printf("%d\n",b);
system(“pause”);
return 0;
}
¿Qué hace el programa? __________________________________________
_______________________________________________________________
Cuál es la salida? _______
¿En qué se diferencia del ejemplo anterior? ____________________________
_______________________________________________________________
Ejercicio 3
Elabore un programa que sume los primeros 25 números enteros guardados en un vector. Se desea imprimir la lista de números y al final la suma de los mismos.
Ejercicio 4
Generar e imprimir un vector de 10 números enteros y encontrar el mayor de ellos. Desplegar el resultado.
Ejercicio 5
Dadas dos listas A y B de igual número de elementos, se desea generar e imprimir una lista C conteniendo las sumas: A[i] + B[i] = C[i]

Clase 10: Estructuras de datos y arreglos.

2007-09-23T22:25:00.000-07:00

Materia: Lógica Computacional
Profesor: Lic. Salomón Aquino.
Objetivos de la clase:
Al final de la clase los alumnos y alumnas serán capaces de:
Asimilar los conceptos generales de estructuras de datos y arreglos.
Resolver problemas usando arreglos en una dimensión (vectores).

Introducción:
Todas las variables que se han considerado hasta ahora son de tipo simple. Una variable de tipo simple consiste de una sola caja de memoria y sólo puede contener un valor cada vez.
Una variable de tipo estructurado consiste en toda una colección de casillas de memoria.
Los tipos de datos estudiados: entero, real, alfabético son considerados como datos de tipo simple, puesto que una variable que se define con alguno de estos tipos sólo puede almacenar un valor a la vez, es decir, existe una relación de uno a uno entre la variable y el número de elementos (valores) que es capaz de almacenar.
En cambio un dato de tipo estructurado, como el arreglo, puede almacenar más de un elemento (valor) a la vez, con la condición de que todos los elementos deben ser del mismo tipo, es decir, que se puede tener un conjunto de datos enteros, reales, etc.
Estructuras de datos:
Estructura de Datos es una colección de datos que se caracterizan por su organización y las operaciones que se definen en ella.
Los datos de tipo estándar pueden ser organizados en diferentes estructuras de datos: estáticas y dinámicas.
Estructura de Datos estáticas:
Son aquellas en las que el espacio ocupado en memoria se define en tiempo de compilación y no puede ser modificado durante la ejecución del programa.
Corresponden a este tipo los arrays y registros
Estructuras de Datos Dinámicas:
Son aquellas en las que el espacio ocupado en memoria puede ser modificado en tiempo de ejecución.
Corresponden a este tipo las listas, árboles y grafos .
Estas estructuras no son soportadas en todos los lenguajes.
La elección de la estructura de datos idónea dependerá de la naturaleza del problema a resolver y, en menor medida, del lenguaje.
Las estructuras de datos tienen en común que un identificador, nombre, puede representar a múltiples datos individuales.
Arreglos o Arrays:
Un arreglo (array) es una colección de datos del mismo tipo, que se almacenan en posiciones consecutivas de memoria y reciben un nombre común. Para referirse a un determinado elemento de un array se deberá utilizar un índice, que especifique su posición relativa en el array.
Un arreglo es una colección finita, homogénea y ordenada de elementos.
Finita:Todo arreglo tiene un límite; es decir,debe determinarse cuál será el número máximo de elementos que podrán formar parte del arreglo.
Homogénea: Todos los elementos del arreglo deben ser del mismo tipo.
Ordenada: Se puede determinar cuál es el primer elemento, el segundo, el tercero,.... y el n-ésimo elmento.
Los arreglos se clasifican de acuerdo con el número de dimensiones que tienen. Así se tienen los:
Unidimensionales (vectores)
Bidimensionales (tablas o matrices)
Multidimensionales (tres o más dimensiones)

Tipos de arreglos:

Arreglos unidimensionales:
Están formados por un conjunto de elementos de un mismo tipo de datos que se almacenan bajo un mismo nombre, y se diferencian por la posición que tiene cada elemento dentro del arreglo de datos.dentro del arreglo, los programas especifican el nombre de éste y el número del elemento, colocándolo dentro de corchetes, como en calificación[3].
Al declarar un arreglo, se debe inicializar sus elementos antes de utilizarlos.
Para declarar un arreglo tiene que indicar su tipo, un nombre único y la cantidad de elementos que va a contener. Por ejemplo, las siguientes instrucciones declaran tres arreglos distintos:
Float costo_partes[50];
Int edad_empleados[100];
Float precios_acciones[25];

Ejemplo de arreglo unidimensional:

Para acceder a valores específicos del arreglo, use un valor de índice que apunte al elemento deseado. Por ejemplo, para acceder al primer elemento del arreglo calificaciones debe utilizar el valor de índice 0 (calificaciones[0]).
Los programas en C++ siempre indizan el primer elemento de un arreglo con 0 y el último con un valor menor en una unidad al tamaño del arreglo.
Inicialización y asignación de valores:
Como se decía anteriormente, antes de utilizar un arreglo es necesario inicializarlo:
Para inicializar todos los elementos de una vez, se colocan dentro de una estructura for que va del primer elemento al último que contiene el arreglo.
Para asignar un valor a un elemento del arreglo se hace por ejemplo:
Calificaciones[0] <- 100;
Cuando se usan arreglos, una operación común es usar una variable índice para acceder a los elementos de un arreglo. Suponiendo que la variable índice I contiene el valor 3, la siguiente instrucción asigna el valor 400 a valores[3]:
valores[I] <- 400;
Partes de un arreglo:
Los componentes. Hacen referencia a los elementos que forman el arreglo, es decir, a los valores que se almacenan en cada una de las casillas del mismo.
Los índices. Permiten hacer referencia a los componentes del arreglo en forma individual, especifican cuántos elementos tendrá el arreglo y además, de qué modo podrán accesarse esos componentes.
Operaciones con vectores:
Las operaciones que se pueden realizar con vectores durante el proceso de resolución de un problema son:
Lectura/ escritura
Asignación
Actualización ( inserción, eliminación, modificación)
Recorrido (acceso secuencial)
Ordenación
Búsqueda

Lectura y escritura de vectores:
Lectura
El proceso de lectura de un arreglo consiste en leer y asignar un valor a cada uno de sus elementos. Normalmente se realizan con estructuras repetitivas, aunque pueden usarse estructuras selectivas.
Usamos los índices para recorrer los elementos del arreglo:
desde i = 1 hasta 70 hacer
leer ( arre[i])
fin_desde
Escritura:
Es similar al caso de lectura, sólo que en vez de leer el componente del arreglo, lo escribimos.
leer (N)
desde i = 1 hasta N hacer
escribir (arre[i])
fin_desde
Asignación e Inicialización de vectores:
Asignación:
No es posible asignar directamente un valor a todo el arreglo; sino que se debe asignar el valor deseado en cada componente. Con una estructura repetitiva se puede asignar un valor a todos los elementos del vector.
Por ejemplo:
arre[1] <- 120 (asignación de un valor constante único a una casilla del vector)
arre[3] <- arre[1] / 4 (asignar una operación)
Se puede asignar un valor constante a todos los elementos del vector:
desde i = 1 hasta 5 hacer
arre[i] <- 3
fin_desde
O bien
arre <- 3 (con arre del tipo arreglo)
Inicialización
Para inicializar con cero todos los elementos del arreglo:
desde i = 1 hasta 70 hacer
arre[i] <- 0
fin_desde
Acceso secuencial y Actualización de vectores:
Acceso Secuencial. (Recorrido)
El acceso a los elementos de un vector puede ser para leer en él o para escribir (visualizar su contenido).
Recorrido del vector es la acción de efectuar una acción general sobre todos los elementos de ese vector.
Actualización.
Incluye añadir (insertar), borrar o modificar algunos de los ya existentes. Se debe tener en cuenta si el arreglo está o no ordenado.
Añadir datos a un vector consiste en agregar un nuevo elemento al final del vector, siempre que haya espacio en memoria.
Fin de la clase.
Gracias por asistir.

Practica 9: Ejercicios con While y Do While.

2007-09-17T19:59:00.000-07:00

Materia: Lógica Computacional.
Profesor: Lic. Salomón Aquino.

Objetivos. Al finalizar la práctica los estudiantes serán capaces de:
• Resolver Problemas usando estructuras While Y Do While
• Aplicar el concepto de centinelas y banderas con estructuras While y Do While.

Estructura Mientras (While)
Al igual que el bucle for, el bucle While es un bucle de precondición. Esto significa que el programa evalúa la condición antes de entrar en la instrucción o instrucciones del cuerpo del bucle. Como consecuencia de esto, los bucles de precondición se pueden ejecutar desde cero hasta varias veces.
La sentencia while se utiliza para generar bucles repetidamente, hasta que la condición deje de ser verdadera.
Sintaxis:
while ( [condición] ) {
Sentencias;
}

Como en todas las estructuras que hemos visto, si se cuenta con una sola sentencia de repetición, no es necesario escribir las llaves.
Estructura Repetir (Do While)
La sentencia do – while se utiliza para especificar un bucle condicional que se ejecuta al menos una vez. Esta situación se suele dar en algunas circunstancias en las que se ha de tener la seguridad de que una determinada acción se ejecutará una o varias veces, pero al menos una vez.
Cuando se construye un bucle usando while, la evaluación de la condición para la continuación del bucle se realiza al comienzo de cada pasada. Sin embargo, a veces es deseable disponer de un bucle en el que se realice el examen al final de cada pasada.
Con esta sentencia se controla la condición al final del bucle. Si ésta se cumple, el programa vuelve a ejecutar las sentencias del bucle.
La única diferencia entre las sentencias while y do...while es que con la segunda el cuerpo del bucle se ejecutará por lo menos una vez.
Sintaxis:
do {
sentencia1;.......
sentenciaN;
} while ([evaluación]);

Ejemplo 1
Elabore un programa en lenguaje C para calcular el promedio de una lista de x números.
Solucion en WHILE:

#include stdio.h>
#include stdlib.h>
main ( )
{
int n , contar=1;
float x , promedio , suma=0;
printf ("Cuantos números desea leer?: ");
scanf ("%d",&n);
while (contar <= n) {
printf ("x= ");
scanf ("%f",&x);
suma +=x;
++contar;
}
promedio=suma/n;
printf ("\nEl promedio es: %.2f\n",promedio);

system(“pause”);
return 0;
}

Solucion en DO-WHILE
#include stdio.h>
#include stdlib.h>
main ( )
{
int n, contar = 1;
float x, promedio, suma = 0;
printf ("Cuantos numeros?: ");
scanf ("%d",&n);
do {
printf("x= ");
scanf ("%f", &x);
suma +=x;
++contar;
} while (contar <= n);
promedio = suma/n;
printf ("\nEl promedio es: %.2f\n",promedio);
system(“pause”);
return 0;
}

Ejemplo 3 : Uso de centinelas
En el ejemplo se introducen notas mientras que ésta sea distinta de centinela, al final imprime cuántas notas se ingresaron, su suma y un mensaje de final. Nota se ha declarado de tipo entero.
#include stdio.h>
#include stdlib.h>
main()
{
const int centinela = -1;
int nota,suma=0;
int cuenta =0;
printf("Introduzca primera nota:\n");
scanf("%d",¬a);
while (nota != centinela)
{
cuenta++;
suma+= nota;
printf("Introduzca la siguiente nota:\n");
scanf("%d",¬a);
}
printf("la suma es: %d\n",suma);
printf("la cuenta fue: %d\n", cuenta);
puts("final");
system(“pause”);
return 0;
}
Ejemplo 4: Uso de centinelas.
Elabore un programa para solicitar el nombre, apellido, edad y la nota promedio de 5 estudiantes de un curso de computación, el programa debe realizar la petición de los datos hasta que se hallan completado los datos.
Solución:
#include stdio.h>
#include conio.h>
#include stdlib.h>
main()
{
int op,edad;
float nota;
char nombre[20], apellido[20];
op=1;
while (op<=5)
{
system("cls");
if(op==5)
{
printf("\n\n\t");
printf("ESTE ES EL ULTIMO ALUMNO");
}
printf("\n\n\t");
printf("REGISTRO DE ALUMNO # %d",op);
printf("\n\n\t\t");
printf ("Nombre: ");
scanf ("%s",nombre);
printf("\n\n\t\t");
printf ("Escriba su Apellido: ");
scanf ("%s",apellido);
printf("\n\n\t\t");
printf ("Escriba su Edad: ");
scanf ("%d",&edad);
printf("\n\n\t\t");
printf ("Escriba su Nota Promedio: ");
scanf ("%f",¬a);
++op;
}
system("cls");
printf("\n\n\n\t");
printf ("\nE L P R O G R A M A H A T E R M I N A D O\n");
system("pause");
return 0;
}
Nota: Este ejemplo aplica el uso de tabuladores para ordenar la información
Ejemplo 5: Uso de banderas.
El siguiente programa utiliza un juego de adivinación de un número, indicando las veces que se necesitan para encontrar el valor de 77. Note el uso de la instrucción continue que provoca que se ignoren todas las instrucciones que siguen a dicha instrucción.
La instrucción while (!iadivinado) indica que mientras sea verdadero que entre al bucle, esto es porque la variable iadivinado se inicializó a FALSO. Esta variable es la bandera del programa, en el momento en que el usuario digite el número 77, la bandera cambia a verdadero y la condición del bucle deja de ser verdadera y se sale.
Observa también que se definieron dos constantes para que la comparación sea numérica, ya que decimos que verdadero vale 1 y falso vale cero, al escribir por ejemplo, la palabra VERDADERO, en realidad, lo que toma la variable es el valor de 1.
#include
#include
#define VERDADERO 1
#define FALSO 0
int main()
{
int inumero_correcto,iadivinado;
int ivalor_introducido,inumero_intentos;
inumero_correcto=77;
iadivinado=FALSO;
inumero_intentos=0;
while (!iadivinado){
printf("por favor, introduzca el numero de la suerte:");
scanf("%d", &ivalor_introducido);
inumero_intentos++;
if(ivalor_introducido== inumero_correcto)
iadivinado=VERDADERO;
else
continue;
printf ("¡Usted ha necesitado %d intentos para adivinarlo!\n", inumero_intentos);
}
system("pause");
return 0;
}

EJERCICIOS:
Ejercicio 1:
Escriba un programa que calcule el resultado de todos los números del uno al cien (1+2+3+4......).
Ejercicio 2:
Escriba un programa que genere las tablas de multiplicar del 1 al 10.
Ejercicio 3:
Haga un programa que pida el número de alumnos de una clase y luego debe permitir ingresar los nombres de dichos alumnos.
Ejercicio 4:
Una compañía de seguros tiene contratados a n vendedores. Cada uno hace tres ventas a la semana. Su política de pagos es que un vendedor recibe un sueldo base y un 10% extra por comisiones de sus ventas.
El gerente de la compañía desea saber cuánto dinero obtendrá en la semana cada vendedor por concepto de comisiones y cuánto tomando en cuenta su sueldo base y sus comisiones
Ejercicio 5:
Haga un programa usando bucle do-While, que pida números y luego calcule la media de esos números. El usuario debe introducir los datos hasta que escriba –1 para finalizar la lectura.

Ejercicio 6:
Escriba un programa usando banderas para imprimir y sumar los términos de la serie 2,5,7,10,12,15....50. Nota que a la serie se le suma 2 y a veces 3. (Puedes auxiliarte del algoritmo visto en clase teórica)
Ejercicio 7:
Elabora el programa que escriba los números del 1 al 100 excepto el número 25. Utiliza la función continue.

Clase 9: Estructura Mientras y Repetir.

2007-09-16T21:38:00.000-07:00

Materia: Lógica Computacional
Profesor: Lic. Salomón Aquino.
Objetivos de la clase:
• Al final de la clase los alumnos y alumnas serán capaces de:
1) Aplicar las estructuras mientras y repetir, en la solución de problemas.
2) Entender y aplicar el uso de centinelas y banderas.

Estructura Mientras (While):
• Se llama Mientras a la estructura algorítmica que se ejecuta mientras la condición evaluada resulte verdadera.
• Se evalúa la expresión booleana y, si es cierta, se ejecuta la instrucción especificada, llamada el cuerpo del bucle. Entonces se vuelve a evaluar la expresión booleana, y si todavía es cierta se ejecuta de nuevo el cuerpo. Este proceso de evaluación de la expresión booleana y ejecución del cuerpo se repite mientras la expresión sea cierta. Cuando se hace falsa, finaliza la repetición.

Estructura repetir (repeat o Do While)
• Se llama Repetir a la estructura algorítmica que se ejecuta un número definido de veces hasta que la condición se torna verdadera.

Representación en pseudocodigo:
• Mientras:
Mientras
Acciones
Fin_mientras
• Repetir:
Repetir
Acciones
Hasta que
EJEMPLO:
Calcular la suma de los cuadrados de los primeros 100 números enteros y escribir el resultado.

Solución estructura Repetir:

Centinelas:
• En un ciclo While controlado por tarea, la condición de While especifica que el cuerpo del ciclo debe continuar ejecutándose mientras la tarea no haya sido completada.
• En un ciclo controlado por centinela el usuario puede suspender la introducción de datos cuando lo desee, introduciendo una señal adecuada llamada centinela.
• Un ciclo Repetir controlado por centinela es cuando el usuario digita una letra para salir como por ejemplo S o N para indicar si desea continuar o no. El bucle debe repetirse hasta que la respuesta del usuario sea “n” o “N”.
• Cuando una decisión toma los valores de –1 o algún posible valor que no esté dentro del rango válido en un momento determinado, se le denomina centinela y su función primordial es detener el proceso de entrada de datos en una corrida de programa.
• Por ejemplo, si se tienen las calificaciones de un test (comprendida entre 0 y 100); un valor centinela en esta lista puede ser –999, ya que nunca será una calificación válida y cuando aparezca este valor se terminará de ejecutar el bucle.
• Si la lista de datos son números positivos, un valor centinela puede ser un número negativo.
• Los centinelas solamente pueden usarse con las estructuras Mientras y Repetir, no con estructuras Desde/Para
Ejemplo de centinelas:
• Suponga que debemos obtener la suma de los gastos que hicimos en nuestro último viaje, pero no sabemos exactamente cuántos fueron.
Si definimos gasto1, gasto2, gasto3, ...., -1 donde
gastoi: real es el gasto número i y
sumgas: real es el acumulador de gastos efectuados.
-1 es el centinela de fin de datos.
• Algoritmo:
Inicio
Sumgas <--0
Leer (gasto)
Mientras gasto <> -1 hacer
Sumgas <-- sumgas + gasto
Leer (gasto)
Fin_mientras
Escribir (sumgas)
Fin
Banderas:
• Conocidas también como interruptores, switch, flags o conmutadores, son variables que pueden tomar solamente dos valores durante la ejecución del programa, los cuales pueden ser 0 ó 1, o bien los valores booleanos True o False.
• Se les suele llamar interruptores porque cuando toman los valores 0 ó 1 están simulando un interruptor abierto/cerrado o encendido/apagado.
Ejemplo de banderas:
• Ejemplo 1: Leer un número entero N y calcular el resultado de la siguiente serie: 1 – 1/2+ 1/3 – 1/4 +.... +/- 1/N.
• Algoritmo:
Inicio
Serie <-- 0
I <-- 1
Leer (N)
Band <-- “T”
Mientras I <= N hacer
Si band = “T” entonces
Serie <--serie + (1/I)
Band <-- “F”
Sino
Serie <-- serie – (1/I)
Band <-- “T”
Fin_si
I <-- I + 1
Fin_mientras
Escribir (serie)
Fin
Fin de la clase.
Gracias por asistir.

Practica 8: Ejercicios con Estructura FOR.

2007-09-10T21:56:00.000-07:00

Materia: Lógica Computacional.
Profesor: Lic. Salomón Aquino.

Objetivos. Al finalizar la práctica los estudiantes serán capaces de:
• Resolver Problemas usando estructuras desde con contadores y acumuladores.

Repetición: El bucle For.
Es el bucle más adecuado para implementar bucles controlados por contador que son bucles en los que un conjunto de sentencias se ejecutan una vez por cada valor de un rango especificado.
Es quizá la más frecuente estructura usada para crear ciclos en C. Esta sentencia incluye una expresión que especifica el valor inicial de un índice, otra expresión que determina cuándo se continúa o no el bucle y una tercera expresión que permite que el índice se modifique al final de cada pasada.
De forma general el ciclo FOR se representaría así:

for ( [valor inicial]; [valor final]; [incremento o decremento])
sentencia;

Y en el caso que el ciclo FOR esté compuesto por más de una línea de sentencias se escribiría así:
for ([valor inicial]; [valor final]; [incremento o decremento])
{
sentencia 1;
sentencia 2;
sentencia N;
}
La inicialización indica una variable (variable de control) que condiciona la repetición del bucle. Si hay más, van separadas por comas:

for (a=1,b=100;a!=b;a++,b- -){
Normalmente se utilizan los bucles For siempre que exista un número necesario y predefinido de iteraciones.
Ejemplo 1:
El siguiente ejemplo muestra como utilizar el for para mostrar un listado de números del 1 al 15.
#include stdio.h>
#include stdlib.h>
main ()
{
int i;
printf ("Numeros del 1 al 15\n\n\n");
for (i=1;i<=15;i++)
printf ("%d\n",i);
system(“pause”);
return 0;
}

Ejemplo 2:
Escriba un programa que escriba los números del 15 al 1 (descendente).
#include stdio.h>
#include stdlib.h>
main ()
{
int i;
printf ("Numeros del 15 al 1\n\n\n");
for (i=15;i>=1;i--)
printf ("%d\n",i);
system(“pause”);
return 0;
}
Ejemplo 3. El siguiente ejemplo suma los cinco primeros números enteros.
#include stdio.h>
#include stdlib.h>
main ()
{
int isuma,ivalor;
isuma=0;
for (ivalor=1; ivalor<=5; ivalor++)
{
isuma+= ivalor;
printf(“\n%d”,isuma);
}
Printf(“\n”);
system(“pause”);
return 0;
}
En C++ se podría haber escrito el fragmento de código del for, de la siguiente manera:
For (int ivalor=1; ivalor<=5; ivalor++);
C++ permite declarar e inicializar la variable de control del bucle dentro del bucle for. Se pueden declarar variables inmediatamente antes de la instrucción que realmente las utiliza.
Los rangos de incremento/ decremento de la variable o expresión de control del bucle pueden ser cualquier valor y no siempre 1, por ejemplo:
#include stdio.h>
#include stdlib.h>
main()
{
int n;
for (n=0; n<100; n+=20)
printf("%d \t %d \n", n, n*n);
system(“pause”);
return 0;
}
Otros ejemplos:
1) int c;
for (c=’A’; c<=’Z’; c++)
printf("%c", c);
2) for (i=9; I>=0; I-=3)
printf("%d", (i*i));
3) for (i=1; i<100; I*=2)
printf("%d", i);
4) # define MAX 25
int i,j;
for (i=0, j=MAX; i<=j; i++,j--)
printf("%d", (i+2*j));
5) double p;
for (p=0.75; p<=5; p+=0.25)
printf(“la respuesta es: %.21f”,p);
6) double x;
for (x=pow(y,3.0); x>2.0; x=sqrt(x))
printf(“x vale %.5e”,x);
Naturalmente, cuando la variable de control no es de tipo int, se tendrán menos garantías de precisión.
Se debe tener cuidado con el uso de las condiciones del bucle For, ya que debemos estar seguros de que en algún momento el bucle terminará y no que seguirá ejecutándose infinitamente. Por eso no es recomendable modificar la condición de incremento como parte de las instrucciones del cuerpo del ciclo, o se corre el riesgo de que se vuelva infinito.

Para abortar un bucle infinito se presiona CTRL + C

La sentencia Continue hace que la ejecución de un bucle vuelva a la cabecera del bucle.
Ejemplo:
#include stdio.h>
#include stdlib.h>
int main()
{
int clave,i;
puts ("introduzca -9 para finalizar");
clave =1;
for (i=0; i<8; i++){
if (clave== -9) continue;
scanf("%d", &clave);
printf("clave %d\n",clave);
}
printf("valores finales i=%d clave=%d", i,clave);
system(“pause”);
return 0;
}
Ejemplo 6
El siguiente ejemplo nos pide una cadena de 10 caracteres y nos muestra dicha cadena en forma invertida.

/* Uso de la sentencia FOR. */
#include stdio.h>
#include stdlib.h>
#define ctam_array 10

int main ()
{
int idespl;
char carray[ctam_array];
printf("Escriba una palabra de 10 espacios:\n");
for (idespl=0; idespl carray[idespl]=getchar();
for (idespl=ctam_array -1; idespl>=0;idespl--)
putchar(carray[idespl]);
printf("\n");
system("pause");
return 0;
}

EJERCICIOS

Desarrolla los siguientes programas:
1. Escriba un programa que pida N números y nos diga cuál es el mayor y cuál es el menor y la posición en que fueron leidos cada uno.
2. Escriba un programa que pida las notas y nombres de cinco alumnos y calcule el promedio general.
3. Escriba un programa que presente en pantalla la tabla de multiplicar entre 1 y 10, requerida por el usuario.
4. Escribir un programa que visualice un triángulo isósceles de 10 filas, como se muestra a continuación:
*
**
***
****
*****
******
*******
********
*********
**********

Clase 8: Estructuras repetitivas e iterativas.

2007-09-09T22:29:00.000-07:00

Materia: Lógica Computacional
Profesor: Lic. Salomón Aquino.
Objetivos de la clase:
Al final de la clase los alumnos y alumnas serán capaces de:
Identificar y diferenciar el uso de las estructuras repetitivas e iterativas.
Entender el uso de contadores y acumuladores y aplicarlo en la solución de problemas repetitivos e iterativos.
ESTRUCTURAS REPETITIVAS E ITERATIVAS:
Son operaciones que se deben ejecutar un número repetido de veces.
El conjunto de instrucciones que se ejecuta repetidamente cierto número de veces, se llama Ciclo, Bucle o Lazo.
Iteración es cada una de las diferentes pasadas o ejecuciones de todas las instrucciones contenidas en el bucle.
Fases de un Programa Cíclico:
Entrada de datos e instrucciones previas
Lazo o bucle
Instrucciones finales o resto del proceso
Salida de resultados

Ejemplo de bucle infinito:

Ejemplo de bucle finito:

Estructura Desde/Para

Se usa frecuentemente cuando se conoce de antemano el número de veces que se ejecutarán las acciones de un bucle.
A la estructura Desde/Para se le conoce como Repetitiva. Para utilizar esta estructura en algoritmos, debemos hacer uso de contadores y algunas veces de acumuladores, cuyos conceptos se describen a continuación:
Contador y Acumulador:
Un contador es una variable cuyo valor se incrementa o decrementa en una cantidad constante cada vez que se produce un determinado suceso o acción.
La inicialización consiste en asignarle al contador un valor. Se situará antes y fuera del bucle.
Representación:
 +
Si en vez de incremento es decremento se coloca un menos en lugar del más.
Ejemplo: i = i + 1
Acumulador: Es una variable que suma sobre sí misma un conjunto de valores para de esta manera tener la suma de todos ellos en una sola variable.
La diferencia entre un contador y un acumulador es que mientras el primero va aumentando de uno en uno, el acumulador va aumentando en una cantidad variable.
Representación:  +
Ejemplo de contador y acumulador:

Fin de la clase.
Gracias por asistir.

Solucion a ejercicios

2007-09-03T22:22:00.000-07:00

Ejercicio 1:

#include iostream.h>
#include stdlib.h>
#include stdio.h>

int main()
{
float venta, comision;
printf("introduzca la cantidad vendida: ");
scanf("%f",&venta);
printf("\n");
if ((venta>=2000 && venta <=10000))
comision = venta*0.07;
else
if (venta>10000 && venta <=20000)
comision = venta * 0.1;
else
if (venta>20000)
comision = venta *0.15;
else
printf("valor menor de 2000\n");
printf("la comision es: %.2f \n",comision);
system("PAUSE");
return 0;
}

Ejercicio 2:

#include iostream.h>
#include stdlib.h>
#include stdio.h>

int main()
{
int a,b;
printf("introduzca el valor de a: ");
scanf("%f",&a);
printf("\n");
printf("introduzca el valor de b: ");
scanf("%f",&b);
printf("\n");
if (a==b)
printf(" a = b \n");
else
{
printf(" no son iguales \n");
if (a > b)
printf("a > b \n");
else
printf("a < b \n");
}

system("PAUSE");
return 0;
}

Ejercicio 4:

#include iostream.h>
#include stdlib.h>
#include stdio.h>

int main()
{
float a, b, r;
int opc=0;
char ch;
printf("introduzca el valor de a: ");
scanf("%f",&a);
printf("\n");
printf("introduzca el valor de b: ");
scanf("%f",&b);
printf("\n");

printf( "Elige el numero en el menu:\n\n" );
printf( "1 - Sumar\n" );
printf( "2 - Restar\n" );
printf( "3 - Multiplicar\n" );
printf( "4 - Dividir\n" );
fflush(stdin);
//opc= getchar();
//printf("opc = %d \n",opc);
ch = getchar();

switch (ch) {
case ('1'):
r = a+b;
break;
case ('2'):
r = a - b;
break;
case ('3'):
r = a * b;
break;
case ('4'):
r = a / b;
break;
default:
printf("La opcion No. %c no esta definida\n", ch);
}

printf("el resultado es : %f \n",r);
system("PAUSE");
return 0;
}

Practica 7: Ejercicios de estructuras selectivas compuestas y multiples.

2007-08-27T22:07:00.000-07:00

Materia: Lógica Computacional.
Profesor: Lic. Salomón Aquino.

OBJETIVOS
Al finalizar la práctica, los estudiantes serán capaces de:
• Resolver Problemas con estructuras de selección Compuesta y Múltiple.

II. Introducción Teórica.
Hasta este punto hemos trabajado con sentencias IF que implementan decisiones que implican una o dos alternativas. En esta práctica se mostrará como se puede utilizar la sentencia IF para implementar decisiones que impliquen varias alternativas.
Estructuras Selectivas Compuestas.
Se identifican porque para solucionarlos se necesita establecer más de una condición. Por lo general dentro de este grupo están incluidos los ifs anidados, en los cuales dentro de un if se encuentra otro y dentro de este hay otro, y así sucesivamente.

Una sentencia IF es anidada cuando la sentencia de la rama verdadera o la rama falsa, es a su vez una sentencia IF. A este tipo de estructura se le conoce como selectiva compuesta o multi-alternativa.
Ejemplo. Si resolvemos el problema de la práctica anterior para saber si un número es positivo, negativo o nulo usando selección compuesta, el módulo sería el siguiente:

Es recomendable utilizar sangrías para diferenciar un if de otro y se deben utilizar con cuidado para evitar posibles ambigüedades.

Ejemplo 1:
Determinar la cantidad de dinero que recibirá un trabajador por concepto de las horas extras trabajadas en una empresa, sabiendo que cuando las horas de trabajo exceden de 40, el resto se consideran horas extras y que éstas se pagan al doble de una hora normal cuando no exceden de 8; si las horas extras exceden de 8 se pagan las primeras 8 al doble de lo que se paga por una hora normal y el resto al triple.

La solucion es la siguiente:

#include
#include
int main ( )
{
float ht,ph,he,het,phe,pt;
printf("\nIntroduzca la horas trabajadas: ");
scanf("%f",&ht);
printf("\n");
printf("\nIntroduzca el precio por hora: ");
scanf("%f",&ph);
printf("\n");
if (ht > 40)
{
he = ht - 40;
if (he > 8)
{
het = he -8;
phe = ph * 2 * 8 + ph * 3 * het;
}
else phe = ph * 2 * he;
pt = ph * 40 + phe;
}
else
pt = ph * ht;
printf("El salario a pagar es %f \n", pt);
system("pause");
return 0;
}

Ejemplo 2:
Se desea agregar una letra para representar la calificación de los alumnos, las calificaciones son notas entre 1 y 10; use los siguientes parámetros: A para calificaciones mayores o iguales a 9, B para calificaciones mayores o iguales a 8, C para calificaciones mayores o iguales a 7, D para calificaciones mayores o iguales a 6, F para todas las demás calificaciones.
#include
<#include stdlib.h>
main ( )
{
int nota;
printf ("Escriba la nota obtenida (valores enteros entre 1-10): ");
scanf ("%d",¬a);
if (nota>=9)
printf ("\nEl concepto en base a su nota es A");
else
if (nota>=8)
printf ("\nEl concepto en base a su nota es B");
else
if (nota>=7)
printf ("\nEl concepto en base a su nota es C");
else
if (nota>=6)
printf ("\nEl concepto en base a su nota es D");
else
printf ("\nEl concepto en base a su nota es F");

printf ("\nEl programa ha terminado\n\n");
system(“pause”);
return 0;
}

Ejemplo 3. Calcular el mayor de tres números enteros.
#include
#include
int main ( )
{
int a, b, c, mayor;
printf ("\nIntroduzca tres enteros: ");
scanf ("%d %d %d",&a, &b, &c);
if (a > b)
if (a > c) mayor = a;
else mayor =c;
else
if (b > c ) mayor = b;
else mayor = c;
printf (“El mayor es %d \n”, mayor);
system(“pause”);
return 0;
}
Estructuras Selectivas Múltiples:
Este tipo de estructuras permiten hacer la selección entre dos o más alternativas. Siempre se realiza una evaluación lógica que es la llave de entrada al ciclo selectivo.
La sentencia que se utiliza para este fin es Switch, que ejecuta una de las alternativas (la que cumpla la condición) siempre y cuando el resultado de la evaluación lógica sea verdadero.
La sentencia switch es especialmente útil cuando la selección se base en el valor de una variable simple o de una expresión simple denominada expresión de control o selector.
El valor de esta expresión puede ser de tipo int o char, pero no de tipo float ni double o string.
Cada posible respuesta es un valor único, constante y diferente de los otros. Además debe ser del mismo tipo que la evaluación lógica.
Si se quiere considerar un proceso para un resultado falso utilizamos la instrucción Default, que es el valor por omisión. Dado que cada uno de los casos puede contener varias expresiones debemos indicarle al compilador que el caso ha terminado y que debe salir del ciclo de selección, para este fin utilizamos la instrucción break. Esta hace que siga la ejecución en la siguiente sentencia al switch.
El ciclo Switch debe estar agrupado entre llaves, la llave para abrir ( { ) se escribe después de la evaluación lógica y la llave para cerrar ( } ), se escribe después del último caso.
switch ( [Evaluación Lógica] )
{
case ( [ posible respuesta 1 ] ) :
Expresión(es);
break;
case ( [ posible respuesta n ] ) :
Expresión(es);
break;
default:
Expresión(es);
break;
}
Si el valor selector no está listado en ninguna etiqueta case, no se ejecutará ninguna de las opciones a menos que se especifique una acción por defecto (omisión). Aunque esta etiqueta default es opcional, se recomienda su uso a menos que se esté absolutamente seguro de que todos los valores del selector estén incluidos en las posibles respuestas del case.

Ejemplo 4:
Escriba un programa tal que al escribir el número de mes muestre el nombre completo del mes (hecho para el primer semestre).

#include
#include
main ( )
{
int mes;
printf ("Escriba el número del mes (primer semestre): ");
scanf ("%d",&mes);
switch (mes) {
case (1):
printf ("Enero");
break;
case (2):
printf ("Febrero");
break;
case (3):
printf ("Marzo");
break;
case (4):
printf ("Abril");
break;
case (5):
printf ("Mayo");
break;
case (6):
printf ("Junio");
break;
default:
printf ("Escribio un numero mayor de seis, recuerde solo primer semestre");
break;
}
printf ("\n\n\nFin del Programa \n");
system(“pause”); return 0;
}
Caso particular de Case
Está permitido tener varias expresiones case en una alternativa dada dentro de la sentencia switch.
Ejemplo 4:
#include
#include
main()
{
int c;
printf("Digite el valor de c:\n");
scanf("%d",&c);
switch ( c ) {
case (0) : case (1) : case (2): case (3) : case (4) :
printf("esta entre 1 y 4\n");
break;
case (5) : case (6) : case (7): case (8) : case (9) :
printf("esta entre 5 y 9\n");
break;
default:
printf("no esta ahi \n");
}
system(“pause”);
return 0;
}
La sentencia switch es útil cuando se quieren elaborar menús para que el usuario seleccione opciones. Un menú de un restaurante presenta una lista de alternativas para que un cliente elija entre sus diferentes opciones. Un menú en un programa de computadora hace la misma función: presentar una lista de alternativas en la pantalla para que el usuario elija una de ellas.
Expresiones condicionales: EL OPERADOR ? :
Las sentencias de selección (if y switch) consideradas hasta ahora, son similares a las sentencias previstas en otros lenguajes, tales como Pascal y Fortran 90. C tiene un tercer mecanismo de selección, una expresión que produce uno de dos valores, resultado de una expresión lógica o booleana (también denominada condición). Este mecanismo se denomina expresión condicional. Una expresión condicional tiene el formato C ? A : B y es realmente una operación ternaria (tres operandos) en el que C, A y B son los tres operandos y ? : es el operador.
Sintaxis: condición ? expresión1 : expresión2
Ejemplo: Recuerdas los ejercicios que hicimos en la práctica 2?
#include stdio.h>
#include stdlib.h>
#include conio.h>
main()
{
int a,b,c;
a=3;
b=8;
c=10;
(a>3 && (b==4 || a + b<=c)) ? printf("verdadero\n") : printf("falso\n");
system(“pause”);
return 0;
}

COMPARACIÓN DE LAS SENTENCIAS IF-ELSE IF Y SWITCH.
Se necesita saber si un determinado carácter car es una vocal.
Solución if-else if
#include
#include
main()
{
char car;
printf("Digite el caracter:\n");
car=getchar();
if ((car=='a')||(car=='A'))
printf("%c es una vocal\n", car);
else if ((car=='e')||(car=='E'))
printf("%c es una vocal\n", car);
else if ((car=='i')||(car=='I'))
printf("%c es una vocal\n", car);
else if ((car=='o')||(car=='O'))
printf("%c es una vocal\n", car);
else if ((car=='u')||(car=='U'))
printf("%c es una vocal\n", car);
else
printf("%c no es una vocal\n", car);
system(“pause”);
return 0;
}

Solución con SWITCH.
#include
#include
main()
{
char car;
printf("Digite el caracter:\n");
car=getchar();
switch (car) {
case ('a'): case ('A'):
case ('e'): case ('E'):
case ('i'): case ('I'):
case ('o'): case ('O'):
case ('u'): case ('U'):
printf("%c es una vocal\n", car);
break;
default:
printf("%c no es una vocal\n", car);
}
system(“pause”);
return 0;
}

III. Ejercicios
1. La empresa Milagrito S.A. tiene la siguiente tabla de parámetros para pagar las comisiones de sus ejecutivos de ventas:

Escriba un programa que al introducir la cantidad vendida por el ejecutivo de ventas, calcule de cuánto será su comisión.
2. En base al valor de dos números enteros, determine si estos son:
A. Iguales.
B. No iguales.
C. El primero es mayor que el segundo.
D. El segundo es mayor que el primero.
E. El primero es mayor o igual que el segundo.
F. El segundo es mayor o igual que el primero.
3. Un restaurante, desea dar a conocer a sus clientes el plato que se ha preparado para cada uno de los tiempos de comida desayuno, almuerzo y cena. El restaurante prepara un plato único para cada uno de los tiempos. Cuando el cliente seleccione entre los tiempos de comida (desayuno, almuerzo o cena) se debe desplegar el detalle de este.
Ejemplo:
Seleccione su tiempo de Comida: desayuno
Detalle
Plátanos, Frijoles, Queso, Crema, Pan y Café.
4: Elabore un programa que pida dos números y que permita mostrar un menú con las cuatro operaciones básicas, donde el usuario pueda seleccionar la operación que desea realizar (basta con que seleccione el número).

Clase 7: Decisiones compuestas y múltiples.

2007-08-26T20:29:00.000-07:00

Materia: Lógica Computacional
Profesor: Lic. Salomón Aquino.
Objetivos de la clase:
Al final de la clase los alumnos y alumnas serán capaces de:
1. Comprender las estructuras selectivas múltiples y compuestas y resolver problemas usando dichas estructuras.
2. Elaborar algoritmos, flujogramas y Diagramas N-S para dichas estructuras.

ESTRUCTURAS SELECTIVAS COMPUESTAS:
• En la solución de problemas encontramos numerosos casos en los que luego de tomar una decisión y marcar el camino correspondiente a seguir, es necesario tomar otra decisión. Dicho proceso puede repetirse numerosas veces.
• En aquellos problemas en donde un bloque condicional incluye otro bloque condicional se dice que un bloque está anidado dentro del otro.
• Diagrama y pseudocódigo:

• Ejemplo 1:
• Determinar la cantidad de dinero que recibirá un trabajador por concepto de las horas extras trabajadas en una empresa, sabiendo que cuando las horas de trabajo exceden de 40, el resto se consideran horas extras y que éstas se pagan al doble de una hora normal cuando no exceden de 8; si las horas extras exceden de 8 se pagan las primeras 8 al doble de lo que se paga por una hora normal y el resto al triple.

• ht = horas trabajadas het = horas extras que exceden de 8
• ph = pago por hora phe = pago por horas extras
• he = horas extras pt = pago que recibe el trabajador
Solución del ejemplo 1:

Algoritmo en pseudocodigo:
Inicio
Leer (ht, ph)
Si ht >40 entonces
He = ht – 40
Si he > 8 entonces
Het = he – 8
Phe = ph * 2 * 8 + ph * 3 * het
Sino
Phe = ph * 2 * he
Fin_si
Pt = ph * 40 + phe
Sino
Pt = ph * ht
Fin_si
Escribir (pt)
Fin

ESTRUCTURAS SELECTIVAS MÚLTIPLES.
• Con frecuencia es necesario que existan más de dos elecciones posibles. Este problema se podría resolver por estructuras selectivas simples o dobles, anidadas o en cascada, pero si el número de alternativas es grande puede plantear serios problemas de escritura y de legibilidad.
• Usando la estructura de decisión múltiple se evaluará una expresión que podrá tomar n valores distintos, 1, 2 , 3, ....,n y según que elija uno de estos valores en la condición, se realizará una de las n acciones o lo que es igual, el flujo del algoritmo seguirá sólo un determinado camino entre los n posibles.
• Esta estructura se representa por un selector el cual si toma el valor 1 ejecutará la acción 1, si toma el valor 2 ejecutará la acción 2, si toma el valor N realizará la acción N.
Ejemplo de selección múltiple:

Solución en diagrama N-S y pseudocodigo:

Fin de la clase.
Gracias por asistir.

Practica 6: Ejercicios de estructuras selectivas simples y dobles.

2007-08-13T16:08:00.000-07:00

Materia: Lógica Computacional.
Profesor: Lic. Salomón Aquino.
OBJETIVOS
Al finalizar la práctica, los estudiantes serán capaces de:
• Identificar las estructuras de selección simple (If) y doble (If-else) en la solución de problemas
• Escribir programas en lenguaje C con estructuras selectivas simples y dobles.

INTRODUCCIÓN TEÓRICA.
Estructuras Selectivas.
La solución de problemas selectivos involucra una serie de acciones en las que la ejecución de alguna dependerá de que se cumplan una o varias condiciones.
Estas estructuras se identifican porque en la fase de solución del problema existe algún punto en el cual es necesario establecer una pregunta, para decidir si ciertas acciones deben realizarse o no.
La Sentencia IF
En C la estructura de control de selección principal es una sentencia IF. La sentencia IF tiene dos formatos o alternativas posibles. El formato más sencillo tiene la sintaxis siguiente:

Supongamos por ejemplo, que tenemos el caso de que los alumnos cuya calificación sea mayor o igual que 6 tienen nota suficiente para aprobar el curso. El enunciado seria el siguiente en pseudocódigo:
Si nota del estudiante mayor o igual que 6
Escriba “APROBADO”

Lo que la estructura de selección hace es evaluar la expresión “nota del estudiante es mayor o igual que 6”. Si el resultado de esta evaluación es Verdadero, entonces se imprime “APROBADO” pero si el resultado de la evaluación es Falso; se ignora la impresión y ejecuta la línea que sigue después de la decisión.
Para una mayor comprensión se presenta el flujograma de la decisión anterior:

En este caso, nos estamos refiriendo a una estructura de selección simple ya que no se ejecuta ninguna acción en el caso que la condición sea falsa.
Si en el ejemplo cambiáramos la condición y dijéramos que si la nota no es mayor o igual a 6 entonces escribir “alumno reprobado”, en este caso nos estamos refiriendo a una estructura de selección doble, ya que existen las dos opciones: que la condición sea verdadera, o que sea falsa.

Sintaxis en lenguaje C
Para la estructura selectiva simple:
If ( [condición] )
[ïnstrucción];
Cuando las instrucciones que se van a imprimir al cumplirse la condición son varias, utilizamos llaves para indicar que corresponden a esa estructura.
If ( [condición] )
{
[instruccion1];
[instruccion2];
}
Para la estructura selectiva doble, agregamos la palabra else para indicar el grupo de instrucciones cuando la condición es falsa.
If ( [condición] )
{
[instruccion1];
[instruccion2];
/* acción que se realiza si la expresión lógica es verdadera*/
}
else
{
[instruccion1];
[instruccion2];
/* acción que se ejecuta si la expresión lógica es falsa */
}

EJERCICIOS RESUELTOS
1) Codificando el ejemplo anterior, tenemos el siguiente programa:
#include
#include
main()
{
float nota;
printf(“introduzca la nota:\n”);
scanf(“%f”, ¬a);
if (nota >=6.0)
printf(“aprobado\n”);
system(“pause”);
return 0;
}
2) Ejemplo Selectivo doble
Tomaremos como base el ejemplo de la nota, pero felicitando a los que aprueben y con un mensaje de aviso a los que reprueben.
En este ejemplo podrás notar que se agregaron llaves ya que son dos mensajes los que se tuvieron que desplegar.

Ejemplo 3. Otra versión del ejemplo anterior:
En base al parámetro de 6.0 como nota para poder aprobar el curso, escriba APROBADO si el alumno cumple con la nota mínima o si ésta es mayor, pero deberá escribir REPROBADO si la nota es menor.

#include
#include
main ( )
{
float nota;
char nombre[30];
printf("Escriba su nombre: ");
scanf("%s",nombre);
printf("\nEscriba su nota: ");
scanf("%f",¬a);
if (nota >= 6)
{
printf ("%s, nos complace informarle que usted ",nombre);
printf ("\n ha APROBADO el curso con una nota de %.2f",nota);
printf ("\ny puede inscribirse en el modulo siguiente.");
}
else
{
printf ("%s, lamentamos informarle",nombre);
printf ("\nque usted ha REPROBADO el curso con una nota de %.2f",nota);
}
printf ("\n\n\n fin del programa \n\n");
system(“pause”);
return 0;
}
Observa las nuevas instrucciones que se han agregado.
Ejemplo 4.
Dados dos números enteros, se desea determinar si el primero es divisible por el segundo, si es cierto desplegar “es divisible” y si no lo es, desplegar “no es divisible”.
#include
#include
int main()
{
int n,d;
printf(“Introduzca dos enteros: “);
scanf(“%d %d”, &n, &d);
if (n%d ==0)
printf(“%d es divisible por %d\n”,n,d);
else
printf(“%d no es divisible por %d\n”,n,d);
system(“pause”);
return 0;
}

Si al ejecutar el programa introducimos 36 y 5, 36 no es divisible por 5 ya que se obtiene un residuo de 1 (n%d ==0 es falsa, entonces se ejecuta la cláusula else).

EJERCICIOS:
Elabora programa en Dev-C++ para los ejercicios siguientes:
1) Dado un número introducido por el usuario, indicar si éste es positivo, negativo o nulo. Resuélvelo usando estructura selectiva simple.
2) Calcular el mayor de dos números leídos del teclado y visualizarlo en pantalla. Utiliza la forma if – else.
3) Escriba un programa que pida un número y a continuación escriba si es par o impar usando la instrucción mod.
4) Calcular el promedio de calificaciones de un alumno. Las dos primeras notas valen 30% cada una y la tercera 40%. Si el promedio es mayor o igual a 7 imprimirá aprobado, de lo contrario dirá reprobado. Si el promedio es igual a 10, dirá alumno excelente. Se desea imprimir el nombre del alumno, código de la materia y el promedio obtenido.

Clase 6: Decisiones Simples y Dobles.

2007-08-12T22:20:00.000-07:00

Materia: Lógica Computacional
Profesor: Lic. Salomón Aquino.

Objetivos de la clase:
• Al final de la clase los alumnos y alumnas serán capaces de:
– Comprender las estructuras selectivas y resolver problemas usando dichas estructuras.
– Elaborar algoritmos, flujogramas y Diagramas N-S para estructuras selectivas simples y dobles.

Estructuras Selectivas:
• Estas estructuras se identifican porque en la fase de solución del problema existe algún punto en el cual es necesario establecer una pregunta, para decidir si ciertas acciones deben realizarse o no.
• Las condiciones se especifican usando expresiones lógicas. La representación de una estructura selectiva se hace con palabras en pseudocódigo (if – then – else o en español si – entonces - sino) y en flujograma con una figura geométrica en forma de rombo.
• Las estructuras selectivas o alternativas se clasifican en:
– Simples
– Dobles
– Compuestas
– Múltiples
Estructuras selectivas simples:
• Se identifican porque están compuestos únicamente de una condición.
• La estructura si – entonces evalúa la condición y en tal caso: Si la condición es verdadera, entonces ejecuta la acción Si (o acciones si son varias). Si la condición es falsa, entonces no se hace nada.
Representación de decisión simple:

Ejemplo 1. Construir un algoritmo tal, que dado como dato la calificación de un alumno en un examen, escriba “Aprobado” en caso que esa calificación fuese mayor que 6.
• Entradas: calificación
• Datos adicionales: un alumno aprueba si la calificación es mayor que 6
• Variables:
• Cal = calificación
• Algoritmo:
Inicio
Leer (cal)
Si cal > 6 entonces
Escribir (“aprobado”)
Fin_si
Fin

Solución Ejemplo 1:

Ejemplo 2 :Dado como dato el sueldo de un trabajador, aplíquele un aumento del 15% si su sueldo es inferior a $1000. Imprima en este caso, el nuevo sueldo del trabajador.
• Salidas: nuevo sueldo. Entradas: sueldo del trabajador
• Datos adicionales:
• Si sueldo es inferior a $1000 entonces aplicar aumento
• aumento = sueldo * 0.15 y Nuevo sueldo = sueldo + aumento
• Variables:
• Sue = sueldo
• Aum = aumento
• Nsue = nuevo sueldo
• Algoritmo:
Inicio
Leer (Sue)
Si Sue < 1000 entonces
Aum <-- Sue * 0.15
Nsue <-- Sue + Aum
Escribir (Nsue)
Fin_si
Fin
Estructuras de Selección Doble:
• Son estructuras lógicas que permiten controlar la ejecución de varias acciones y se utilizan cuando se tienen dos opciones de acción, por la naturaleza de estas se debe ejecutar una o la otra, pero no ambas a la vez, es decir, son mutuamente excluyentes.

Ejemplo 3: Dado como dato la calificación de un alumno en un examen, escriba “aprobado” si su calificación es mayor que 8 y “Reprobado” en caso contrario.

Ejemplo 4: Dado como dato el sueldo de un trabajador, aplicar un aumento del 15% si su sueldo es inferior a $1000 y 12% en caso contrario, luego imprimir el nuevo sueldo del trabajador.

Fin de la clase.
Gracias por asistir.

Practica 5 Ejercicios de estructuras secuenciales

2007-07-30T20:12:00.000-07:00

Materia: Lógica Computacional.
Profesor: Lic. Salomón Aquino

1. Leer el sueldo de tres empleados y aplicarles un aumento del 10, 12 y 15% respectivamente. Desplegar el resultado.

2. Escribir un programa que calcule el salario de un trabajador de la manera siguiente. El trabajador cobra un precio fijo por hora y se le descuento el 10% en concepto de impuesto sobre la renta. El programa debe pedir el nombre del trabajador, las horas trabajadas y el precio que cobra por hora. Como salida debe imprimir el sueldo bruto, el descuento de renta y el salario a pagar.

3. Programa que pida el precio de un artículo y calcule su valor aplicándole un 13% de IVA.

4. Dada una medida de tiempo expresada en horas, minutos y segundos con valores arbitrarios, elabore un programa que transforme dicha medida en una expresión correcta. Por ejemplo, dada la medida 3h 118m 195s, el programa deberá obtener como resultado 5h 1m 15s.

5. Escriba un programa que calcule el área de un triángulo rectángulo, dada la altura y la base.

6. Elabore un programa que realice la conversión de cm. a pulgadas.
Donde 1cm = 0.39737 pulgadas.
Por lo tanto, el usuario proporcionara el dato de N cm. y el programa dirá a cuantas pulgadas es equivalente.

7. Elabore un programa que realice la conversión de pulgadas a cm.
Donde 1 cm. = 0.39737 pulgadas.
Por lo tanto, el usuario proporcionara el dato de N pulgadas y el programa dirá a cuantos centímetros equivale.

8. Elabore un programa que realice la conversión de metros a pies
Donde 1 m = 3.2808 pies.
Por lo tanto, el usuario proporcionara el dato de N m y el programa dirá a cuantos pies equivale.

9. Elabore un programa que realice la conversión de pies a metros
Donde 1 m = 3.2808 pies.
Por lo tanto, el usuario proporcionara el dato de N pies y el programa dirá a cuantos metros equivale.

10. Elabore un programa que realice la conversión de kilogramos a libras
Donde 1 Kg. = 2.2046 libras.
Por lo tanto, el usuario proporcionara el dato de N Kg. y el programa dirá a cuantas libras equivale.

11. Elabore un programa que realice la conversión de libras a kilogramos
Donde 1 Kg. = 2.2046 libras.
Por lo tanto, el usuario proporcionara el dato de N libras y el programa dirá a cuantos kilogramos equivale.

Clase 5 Entrada y Salida Estándar.

2007-07-29T20:51:00.000-07:00

Materia: Lógica Computacional
Profesor: Lic. Salomón Aquino.
Objetivos de la clase:
• Al final de la clase los alumnos y alumnas serán capaces de:
• Comprender la sintaxis de las funciones printf() y scanf().
• Utilizar correctamente las funciones printf() y scanf().

La función printf()
• La función printf permite escribir una lista de datos con un formato preestablecido. Acepta diferentes tipos de argumentos: carácter, valor numérico entero o real o cadena de caracteres, y los escribe según un formato especificado sobre la salida estándar. La forma de la función printf es:
• printf ("formato", arg1, arg2, ..., argn);
• donde argi pueden ser constantes, variables o expresiones, y “formato” es una serie de caracteres en la cual se pueden encontrar dos tipos de datos: un mensaje o texto a escribir literalmente, y los símbolos especificadores del formato con el cual se van a escribir las variables dadas como argumentos.
• Por ejemplo: printf ("Esto es un mensaje\n");
• Escribe la cadena Esto es un mensaje seguida de un salto de línea (debido al \n)

Ejemplo de printf()
#include < stdio.h >
main()
{
int i; char letra; float f; char string[10]="hola";
i = 1; letra='a'; f = 3.15;
/* \n en el printf hace que salte de linea */
printf(" El numero entero es %d\n", i);
printf(" El numero real es %f\n",f);
printf(" La letras es %c\n", letra);
printf(" El string es %s\n",string);
system(“pause”);return 0;
}
Especificadores de formato:
• Los especificadores de formato deben ir precedidos del signo %. Algunos de ellos son:
• %c carácter (char)
• %d número entero (int)
• %ld número entero (long)
• %f número real (float)
• %lf número real (double)
• %s cadena de caracteres

• Por cada argumento a imprimir debe existir un especificador de formato, que indica el formato en el cual se va a mostrar el dato. Por ejemplo, siendo letra una variable de tipo char con el valor ‘A’, la instrucción
printf (“El código ASCII de %c es %d”, letra, letra);
escribirá:
El código ASCII de A es 65

Otros ejemplos de printf:
• printf (“\nEl cuadrado de %f vale %f”, x, x*x);
• printf (“\nLa edad de %s es %d años”, “Juan”, edad);
• printf (“\nSeno (%lf) = %lf\n”, x, sin(x));

• La función printf puede emplearse sin argumentos, en cuyo caso sólo se imprimen los caracteres presentes en la cadena de formato.

Caracteres opcionales:
• Entre el símbolo "%" y el carácter que especifica la notación a emplear se pueden insertar ciertos caracteres opcionales. Son los siguientes:

– El signo (-) para que el dato se ajuste por la izquierda, en lugar de hacerlo por la derecha, que es lo establecido por defecto.
– Un número que indica la longitud mínima en caracteres que tiene el campo donde se mostrará el dato. Los espacios hacen de caracteres de relleno.
– Un punto decimal (.) seguido de una cifra que indica el número de dígitos tras el punto decimal de un dato real o el número mínimo de dígitos para un entero o el número máximo de caracteres de una cadena que serán impresos

Ejemplo de caracteres opcionales:
• %8d imprime un número decimal (int) alineado por la derecha y en un campo de al menos ocho caracteres.

• %-25s imprime una cadena de caracteres alineada por la izquierda y asegurando una longitud mínima de 25 caracteres (reserva al menos 25 espacios, si la longitud del valor a visualizar es mayor de 25 se visualizan todos).

• %.6f imprime un número real (float) con un máximo de 6 cifras significativas en la parte fraccionaria.

La función scanf()
• La función scanf permite leer valores desde la entrada estándar y almacenarlos en las variables que se especifican como argumentos. Éstas deben ir normalmente precedidas por el símbolo &. La sintaxis es:
scanf ("formato", arg1, arg2, ..., argn);
• donde debe haber tantos especificadores en la cadena de “formato” como variables en la lista de argumentos. Por ejemplo,
int n;
double x;
scanf ("%d%lf", &n, &x);
• para leer un valor de tipo int y otro de tipo double. Los valores se introducirán desde la entrada estándar separándolos por espacios o retornos de carro. En la cadena de formato aparecen especificadores de formato (los mismos que ya se han visto) pero nunca deben aparecer caracteres ordinarios.

#include < stdio.h >
main() {
int i; char c; float f; char string[10];
printf("Introduce la letra: "); scanf("%c",&c);
printf(" Introduce el numero entero: "); scanf("%d",&i);
printf("Introduce el numero real: "); scanf("%f",&f);
printf("Introduce el string: "); scanf("%s",&string);
printf("Los valores introducidos son: %c %d %f %s \n",c,i,f,string);
system(“pause”);return 0;
}

Ejemplo de uso de printf() y scanf()
Como ejemplo del uso de printf y scanf, sea un programa que lee dos números del teclado y calcula e imprime la suma de ambos:
/* Programa que lee dos números y los suma */
#include < stdio.h >
void main (void)
{
int a, b, suma;
printf ("\nIntroduzca a y b: ");
scanf ("%d%d", &a, &b);
printf ("\n a vale: %d; b vale %d", a, b);
suma = a + b;
printf ("\n\nLa suma de a y b vale: %d\n", suma);
}

Fin de la clase.
Gracias por asistir.

Practica 4: Ejercicios de programas basicos en lenguaje C

2007-07-23T18:35:00.000-07:00

Profesor: Lic. Salomon Aquino
Materia: Logica Computacional

Escriba los siguientes ejemplo de programas en C en el compilador Devcpp:

Ejemplo 1
Primer programa en lenguaje C:

/* Mi primer programa completo en Lenguage C.
Imprime un texto en pantalla. */

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

int main()

{

printf(“Hola mundo!!\n”);
system("pause");
return 0;
}

Modifique el programa para que en vez de Hola Mundo aparezca tu nombre, por ejemplo: Hola Salomon Aquino.

Ejemplo 2
Segundo programa en lenguaje C:

#include < stdio.h >
#include < stdlib.h >
#include < conio.h >
main()
{
int a, b, c, suma;
a=6;
b=4;
c=17;
suma = a + b + c;
printf ("\n La suma es : %d ", suma);
printf("\n");
system("pause");
return 0;
}

ahora vamos a modificar el programa para que solicite los valores de a, b y c y estos se introduzcan por el teclado, el programa quedaria de la siguiente manera:

#include < stdio.h >
#include < stdlib.h >
#include < conio.h >
main()
{
int a, b, c, suma;

printf("Introduzca el valor de a : ");
scanf("%d", &a);
printf("\n");

printf("Introduzca el valor de b : ");
scanf("%d", &b);
printf("\n");

printf("Introduzca el valor de c : ");
scanf("%d", &c);
printf("\n");

suma = a + b + c;
printf ("\n La suma es : %d ", suma);
printf("\n");
system("pause");
return 0;
}

Ejemplo 3

/* Este ejemplo muestra el uso de variables tipo char y tipo int */
#include < stdio.h >
#include < stdlib.h >
#include < conio.h >

main ( )
{
char nombre[30];
int edad;
printf ("Escriba su nombre: ");
scanf ("%s", nombre);
printf ("\n Escriba la edad de %s: ", nombre);
scanf ("%d", &edad);
printf("\n");
printf ("Su nombre es: %s ", nombre);
printf("\n");
printf ("Su edad es: %d ", edad);
printf ("\n");
system("pause");
return 0;
}

Ejemplo 4
Este programa muestra es uso de variables tipo char.

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

main ( )
{
char nombre[30] ;
printf ("Esta es una secuencia de sentencias\n");
printf("Ahora escriba su nombre (solo su primer nombre): ");
scanf("%s",nombre);
printf ("\nMucho gusto %s.",nombre);
printf ("\nEspero que te estes divirtiendo y aprendiendo el Lenguaje C \n");
printf("Con mucha dedicacion y esfuerzo saldras bien en tus practicas\n");
system("pause");
return 0;
}

Ejemplo 5
Este ejemplo muestra el uso de variables tipo float, pide 3 salarios y los suma.

#include < stdio.h >
#include < stdlib.h >
#include < conio.h >
main()
{
float salario1, salario2, salario3, suma;

printf("Introduzca el valor de salario1 : ");
scanf("%f", &salario1);
printf("\n");

printf("Introduzca el valor de salario2 : ");
scanf("%f", &salario2);
printf("\n");

printf("Introduzca el valor de salario3 : ");
scanf("%f", &salario3);
printf("\n");

suma = salario1 + salario2 + salario3;
printf ("\n La suma es : %.2f ", suma);
printf("\n");
system("pause");
return 0;
}

Ejercicios:
Escribe un programa en lenguaje C para los siguientes ejercicios:

1. Escribe un programa que calcule el área de un círculo de cualquier radio.
2. Escribe un programa que lea una cantidad depositada en un banco y que calcule la cantidad final después de aplicarle un 20% de interés.
3. Un maestro desea saber que porcentaje de hombres y que porcentaje de mujeres hay en un grupo de estudiantes.
4. Un alumno desea saber cual será su calificación final en la materia de Lógica Computacional. Dicha calificación se compone de tres exámenes parciales cuya ponderación es de 30%, 30% y 40%
5. Una farmacia aplica al precio de los remedios el 10% de descuento. Hacer un programa que ingresado el costo de los medicamentos calcule el descuento y el precio final

Clase 4: Estructura de un programa en lenguaje C.

2007-07-22T21:07:00.000-07:00

Materia: Lógica Computacional
Profesor: Lic. Salomón Aquino.
Objetivos de la clase:
Al final de la clase los alumnos y alumnas serán capaces de:
1. Comprender la estructura de los programas en lenguaje C.
2. Elaborar programas secuenciales usando la estructura de los programas en lenguaje C.

Primer programa en lenguaje C:
/* Mi primer programa completo en Lenguage C.
Imprime un texto en pantalla. */

#include

int main()

{

printf(“Hola mundo!!\n”);
system("pause");
return 0;
}

Segundo programa en lenguaje C:
#include
#include
#include
main()
{
int a, b, c, suma;
a=6;
b=4;
c=17;
suma = a + b + c;
printf ("\n La suma es : %d ", suma);
printf("\n");
system("pause");
return 0;
}

Directivas de Librerías:
• En esta sección se escriben aquellas sentencias que proveerán herramientas útiles para desarrollar el programa.
• Para el caso específico de lenguaje C, en esta sección se escriben los nombres de las galerías de encabezados que serán utilizadas (incluídas).
• Se antecede a cada galería la instrucción #include y seguido de esta se escribe entre signos de menor que y mayor que, el nombre de la galería.
• Ejemplos de la sección de utilerías son las siguientes:
#include (stdio.h) #include (stdlib.h)
#include (conio.h) #include (string.h>)
#include (ctype.h) #include (math.h)
#include (dos.h)

Nota: En las instrucciones #include, sustituya los parentesis por los simbolos "<" y ">"

La función main()
• Todos los programas en lenguaje C deben comenzar con la función main().
• Toda función debe retornar un valor, la funcion main() retorna un valor entero, por eso los programas deben terminar con un return 0;
• La función puede declararse como int main() o solo main(), las dos formas son validas.

Los comentarios:
• Los comentarios son lineas incluidas en un programa que no realizan ninguna accion, solo sirven para agregar explicaciones o documentar el programa.
• Hay dos tipos de comentarios: de una linea y de varias lineas.
• /* */ Para comentarios cuando ocupan más de una línea de texto. Lo que se escriba entre estos dos símbolos será ignorado por el compilador.
• // para comentarios en una única línea de texto.

Declaración de variables:
• C requiere que se declaren las variables que se utilizarán en el desarrollo del programa. Estas se declaran precedidas por un palabra reservada que le indica al compilador el tipo de datos que se almacenará en la variable.
• =
• Se pueden también declarar múltiples variables en la misma línea:
• , ....
• Así por ejemplo:
• Int longitud; int valor=99;
• Int valor1, valor2;
• float salario, estatura;

Instrucciones del programa:
• Las instrucciones de un programa en C se encuentran entre las llaves de inicio y fin de la funcion main().
• Todas las instrucciones del programa deben finalizar con un punto y coma (;)
• Ejemplo: Int edad;
• La funcion printf() se utiliza como instrucción de salida.
• La funcion scanf() se utiliza como instrucción de entrada de datos.
• la instrucción system(“pause”) que es necesaria para que la pantalla se detenga temporalmente cuando corremos el programa, ya que si no ponemos esa instrucción, no veríamos lo que hace el programa porque mostraría rápidamente los resultados.
• Esta instrucción se encuentra en la librería que deberá ser declarada en la cabecera del programa.

Practica 3: ejercicios de diagramas de flujo

2007-07-16T21:03:00.000-07:00

Materia: Lógica Computacional
Profesor: Lic. Salomón Aquino

Objetivos: Al final de la clase los alumnos serán capaces de:
1. Comprender las estructuras secuenciales y resolver problemas usando dichas estructuras.
2. Elaborar algoritmos, y flujogramas para estructuras secuenciales.

ESTRUCTURAS BÁSICAS.
Un problema se puede dividir en acciones elementales o instrucciones, usando un número limitado de estructuras de control (básicas) y sus combinaciones que pueden servir para resolver dicho problema.
Las Estructuras Básicas pueden ser:
Secuenciales: cuando una instrucción del programa sigue a otra.
Selección o decisión: acciones en las que la ejecución de alguna dependerá de que se cumplan una o varias condiciones.
Repetición, Iteración: cuando un proceso se repite en tanto cierta condición sea establecida para finalizar ese proceso.

Estructura Secuencial.
Se caracteriza porque una acción se ejecuta detrás de otra. El flujo del programa coincide con el orden físico en el que se han ido poniendo las instrucciones.
Dentro de este tipo podemos encontrar operaciones de inicio/fin, inicialización de variables, operaciones de asignación, cálculo, sumarización, etc.
Este tipo de estructura se basa en las 5 fases de que consta todo algoritmo o programa:
Definición de variables (Declaración)
Inicialización de variables.
Lectura de datos
Cálculo
Salida

Ejemplo 1.
Se desea encontrar la longitud y el área de un círculo de radio 5.
Solución.
El objetivo del ejercicio es encontrar la longitud y el área de un círculo con un radio conocido y de valor 5. Las salidas serán entonces la longitud y el área. (Fase 5 del algoritmo)
Sabemos que la longitud de un círculo viene dada por la fórmula 2 * pi * radio y que el área viene dada por pi * radio al cuadrado. (Fase 4 del algoritmo)

Si definimos las variables como: (fase 1 del algoritmo)
L = Longitud A = área R = radio pi = 3.1416 hagamos el algoritmo:
Inicio
Pi <- 3.1416 (definición de un valor constante)
R <- 5 (radio constante ya que es conocido su valor)
A <- pi * R ^ ² (asignación del valor del área)
L <- 2 * pi * R (asignación del valor de la longitud)
Escribir (A, L) (salida del algoritmo)
Fin

Representación en Diagrama de Flujo para el ejemplo:

En este ejercicio no existen datos de entrada ya que para calcular el área y la longitud necesitamos únicamente el radio y el valor de Pi los cuales ya son dados en el problema.

Ejemplo 2.
Modificar el problema anterior para que sea capaz de calcular el área y la longitud de un círculo de cualquier radio requerido.

Solución.
El problema es el mismo con la variante de que ahora ya existe un dato de entrada, puesto que el radio puede ser cualquiera y será necesario que el usuario sea quien lo introduzca de teclado. Usando las misma definición de variables tenemos:
Algoritmo:
Inicio
pi <- 3.1416 (fase de inicialización)
Leer (R) (fase de lectura)
A <- pi * R ^ ² (fase de cálculos)
L <- 2 * pi * R
Escribir ( A, L ) (fase de salida)
Fin
Note que la instrucción de asignación fue cambiada por la instrucción leer.
En el flujograma deberán cambiarse también los símbolos que los representan:

Ejemplo 3.
Leer el sueldo de tres empleados y aplicarles un aumento del 10, 12 y 15% respectivamente. Desplegar el resultado.
Salidas: Sueldos finales
Entradas: Salarios de los empleados
Datos adicionales: aumentos del 10, 12 y 15%
Cálculos:
Sueldo final = sueldo inicial + aumento
Aumento = sueldo inicial * porcentaje/100
Definición de variables:
Sf1, Sf2, Sf3 = los sueldos finales
S1, S2, S3 = salarios de los empleados
Aum1, aum2, aum3 = aumentos

ALGORITMO
Inicio
Leer (S1,S2,S3)
Aum1 <- S1 * 0.10
Aum2 <- S2 * 0.12
Aum3 <- S3 * 0.15
Sf1 <- S1 + Aum1
Sf2 <- S2 + Aum2
Sf3 <- S3 + Aum3
Escribir (SF1,SF2,SF3)
Fin

FLUJOGRAMA:

Ejercicios para resolver en la clase:
Para cada ejercicio escriba su algoritmo en pseudocodigo y su flujograma.
1. Escribe un programa que calcule el área de un círculo de cualquier radio.
2. Escribe un programa que lea una cantidad depositada en un banco y que calcule la cantidad final después de aplicarle un 20% de interés.
3. Un maestro desea saber que porcentaje de hombres y que porcentaje de mujeres hay en un grupo de estudiantes.
4. Un alumno desea saber cual será su calificación final en la materia de Lógica Computacional. Dicha calificación se compone de tres exámenes parciales cuya ponderación es de 30%, 30% y 40%
5. Una farmacia aplica al precio de los remedios el 10% de descuento. Hacer un programa que ingresado el costo de los medicamentos calcule el descuento y el precio final

6. Haga tabla de seguimiento para encontrar los resultados de las variables dadas en el siguiente algoritmo:
Algoritmo Verifica
Entero: x, y, z
Inicio
X <- 40
Y <- 25
Z <- x – y
Y <- X
Escribir ( y, x)
Escribir (z)
Fin.

Clase 3: Diagramas de Flujo.

2007-07-15T16:45:00.000-07:00

Materia: Lógica Computacional
Profesor: Lic. Salomón Aquino.
Fecha: 16/07/07

Objetivos de la clase:
Al final de la clase los alumnos y alumnas serán capaces de:
1. Comprender y aplicar el concepto de diagrama de flujos.
2. Comprender y aplicar las reglas de construcción de los diagramas de flujos.
3. Elaborar diagramas de flujo.

Los Diagramas de Flujo:
Son la representación gráfica de la solución algorítmica de un problema.
Para diseñarlos se utilizan determinados símbolos o figuras que representan una acción dentro del procedimiento.
Utilizan unos símbolos normalizados, con los pasos del algoritmo escritos en el símbolo adecuado y los símbolos unidos con flechas, denominadas líneas de flujo, que indican el orden en que los pasos deben ser ejecutados.

Para su elaboración se siguen ciertas reglas:
Se escribe de arriba hacia abajo y de izquierda a derecha
Siempre se usan flechas verticales u horizontales, jamás curvas
Se debe evitar cruce de flujos
En cada paso se debe expresar una acción concreta
Secuencia de flujo normal en una solución de problema
Tiene un inicio
Una lectura o entrada de datos
El proceso de datos
Una salida de información
Un final

Simbología para diseñar flujogramas.

VENTAJAS DE USAR DIAGRAMAS DE FLUJO
Rápida comprensión de las relaciones
Análisis efectivo de las diferentes secciones del programa
Pueden usarse como modelos de trabajo en el diseño de nuevos programas o sistemas
Comunicación con el usuario
Documentación adecuada de los programas
Codificación eficaz de los programas
Depuración y pruebas ordenadas de programas

DESVENTAJAS DE LOS DIAGRAMAS DE FLUJO
Diagramas complejos y detallados suelen ser laboriosos en su planteamiento y diseño
Acciones a seguir tras la salida de un símbolo de decisión, pueden ser difíciles de seguir si existen diferentes caminos
No existen normas fijas para la elaboración de los diagramas de flujo que permitan incluir todos los detalles que el usuario desee introducir.

Ejemplo de diagrama de flujo:

Ejercicio:
Indica cuáles de los siguientes diseños son válidos según las reglas de construcción de flujogramas:

Practica 2: Jerarquia de operadores en C++

2007-07-09T20:37:00.000-07:00

Materia: Logica Computacional
Profesor: Lic. Salomón Aquino

Objetivos. Al finalizar la práctica los alumnos y alumnas sran capaces de:

Asimilar y poner en práctica los conceptos de datos y operadores, además conocerá sus tipos.
Resolver expresiones usando la jerarquía de operadores.
Aplicar la jerarquía de operadores (lógicos y aritméticos) propias del Lenguaje C.

OPERADORES ARITMÉTICOS.

Sirven para realizar operaciones aritméticas básicas. Los operadores aritméticos C siguen las reglas algebraicas típicas de jerarquía o prioridad.

Los paréntesis se utilizan en las expresiones de C de manera muy similar a como se usan en las expresiones algebraicas, sirven para indicar que la expresión dentro de ellos se debe realizar primero. Por ejemplo, para multiplicar a por la cantidad b+c escribimos:

a * (b + c)

Pow es la función que permite realizar las potencias. Por ejemplo x=23 se podría presentar en C de las maneras siguientes: x=pow (2 , 3); o x=2*2*2;

Las reglas de precedencia o jerarquía de operadores son guías de acción, que le permiten a C calcular expresiones en el orden correcto. Cuando decimos que una evaluación o cálculo avanza de izquierda a derecha, nos estamos refiriendo a la asociatividad de los operadores.

Ejemplo 1:

El siguiente ejemplo contiene módulo (%), multiplicación, división, adición y sustracción.

Algebraicamente: z= pr mod q + w ÷ / x - y

En C: z = p * r % q + w / x – y;

1, 2, 4, 3, 5

Los números de las operaciones indican el orden en el cual C valorará o calculará los operadores. La multiplicación, el módulo y la división, serán evaluadas primero, en un orden de izquierda a derecha (es decir, se asocian de izquierda a derecha), en vista de que tienen precedencia mayor que la suma y la resta. La suma y la resta serán calculadas después. También ellas se evaluarán de izquierda a derecha.

No todas las expresiones con varios pares de paréntesis contienen paréntesis anidados. La expresión a * ( b + c) + c * (d + e) no contiene paréntesis anidados. En vez de ello, se dice que estos paréntesis están “en el mismo nivel”. En ese caso, se calcularán las expresiones del paréntesis primero y en un orden de izquierda a derecha

Ejemplo 2:

Se tiene la siguiente expresión polinómica de segundo grado y=2*5*5+3*5+7, se desea evaluarla y encontrar el resultado.

Solución:

Paso 1. y = 2 * 5 * 5 + 3 * 5 + 7;
2 * 5 = 10 (Multiplicación más a la izquierda primero)

Paso 2. y = 10 * 5 + 3 * 5 + 7;
10 * 5 = 50 (Multiplicación más a la izquierda)

Paso 3. y = 50 + 3 * 5 + 7;
3 * 5 = 15 (Multiplicación antes de la suma)

Paso 4. y = 50 + 15 + 7;
50 + 15 = 65 (Suma más a la izquierda)

Paso 5. y = 65 + 7;
65 + 7 = 72 (Última operación)

Operadores de Igualdad en Lenguaje C.

Como ya hemos visto, en Lenguaje C, los operadores algebraicos tienen la misma función, pero cambia la forma en la que se presentan.

Los operadores de igualdad no son la excepción y al hablar de estos nos referimos a igual (=) y no igual (≠). El resultado que generan los operadores de igualdad, puede ser un cero (falsa) o uno (verdadero).

Tabla de Operadores de Igualdad.

Ejemplo:

a = b , se muestra en Lenguaje C de la siguiente manera: a = = b;

y a ≠ b , se escribiría así: a ! = b.

Operadores Relacionales en Lenguaje C.

Los enunciados ejecutables de C, pueden llevar a cabo ACCIONES (como cálculos o salidas de datos), o tomar DECISIONES (evaluación de dos o más expresiones). Por ejemplo, podríamos necesitar tomar una decisión en un programa para determinar si la calificación de una persona en un examen es mayor o igual a 7, y si es así, imprimir el mensaje “Felicidades usted pasó”.

Los operadores relacionales tienen un mismo nivel de precedencia y se asocian de izquierda a derecha. En C, una condición puede ser cualquier expresión que genere un valor de verdad falso o verdadero.

Tabla de Operadores Relacionales.

Ejemplo
Dados a=1, b=2 y c=3 efectúe la siguiente expresión: 10 * a > c * 10 + b

Paso I. 10 * 1 > 3 * 10 + 2

Paso II. 10 > 30 + 2

Paso III. 10 > 32

Respuesta FALSO

Operadores Lógicos.

Se utilizan para evaluar dos o más relaciones, estos operadores son AND, OR y NOT, siempre devuelven como resultado un 0 (falso) o 1 (verdadero). Se evalúan primero las relaciones y luego se evalúan las operaciones entre sí tomando en cuenta los operadores lógicos.

El Operador AND.

Se evalúan primero las expresiones aritméticas, luego las relacionales y lógicas. Con el operador and, para que la respuesta sea verdadera, ambas relaciones deben ser verdaderas, de lo contrario, con una que sea falsa, el resultado de la evaluación es falso. En C se utiliza && para representar el operador AND.

Ejemplo 1:

3 > 5 and 3 < 10; en Lenguaje C se representa por 3 > 5 && 3 < 10;

Para este ejemplo, la primera relación da como resultado FALSO (pues 3 no es mayor que 5) mientras que la segunda relación da como resultado VERDADERO (3 es menor que 10). El siguiente paso es evaluar los resultados con el operador lógico, en otras palabras FALSO and VERDADERO esta evaluación da como resultado FALSO. Si el resultado de las dos evaluaciones diera como resultado VERDADERO, entonces el resultado seria VERDADERO.

Ejemplo 2:

5 > 2 and 10 ≥ 9; en Lenguaje C se representa por 5 > 2 && 10 >= 9;

En esta expresión las dos evaluaciones dan como resultado un valor VERDADERO, por lo que al evaluar VERDADERO and VERDADERO da como resultado VERDADERO.

El Operador OR.

En este caso, al evaluar las expresiones aritméticas y luego las relacionales y lógicas; para que la respuesta sea verdadera, una de las relaciones debe ser VERDADERA, si todas las evaluaciones son FALSAS, el resultado de la evaluación es falso. En C se utiliza || para representar el operador OR.

El Operador NOT.

Este operador tiene la función de cambiar el valor de verdad al penúltimo resultado obtenido de evaluar la expresión. Si al final se obtiene not (verdadero), el resultado será FALSO; y si es not (falso), el resultado será VERDADERO. En C se utiliza ! para representar dicho operador.

Ejemplo 1:

Not(99 >= 50 or 10 > = 75); en Lenguaje C se representa !( 99 >= 50 || 10 >= 75)

Al evaluar esta expresión, notamos que en la primera parte nos da un verdadero y en la segunda nos da un falso. De verdadero or falso obtenemos verdadero y finalmente not de verdadero nos da como resultado un FALSO.

Jerarquía general de operadores en Lenguaje C.

ASOCIATIVIDAD

En una expresión tal como 3 * 4 + 5 el compilador realiza primero la multiplicación - por tener el operador * prioridad más alta - y luego la suma, por tanto, produce 17. Para forzar un orden en las operaciones se deben utilizar paréntesis.

3 * (4 + 5) produce 27, ya que 4 + 5 se realiza en primer lugar.

La asociatividad determina el orden en que se agrupan los operadores de igual prioridad; es decir, de izquierda a derecha o de derecha a izquierda. Por ejemplo,

X – y + z se agrupa como ( x – y ) + z

Ya que – y +, con igual prioridad, tienen asociatividad de izquierda a derecha. Sin embargo,

x = y = z se agrupa como x = ( y = z ) dado que su asociatividad es de derecha a izquierda.

Uso de Paréntesis

Los paréntesis se pueden utilizar para cambiar el orden usual de evaluación de una expresión determinada por su prioridad y asociatividad. Las subexpresiones entre paréntesis se evalúan en primer lugar según el modo estándar y los resultados se combinan para evaluar la expresión completa. Si los paréntesis están anidados, es decir, un conjunto de paréntesis contenido en otro, se ejecutan en primer lugar los paréntesis más internos. Por ejemplo, considérese la expresión ( 7 * (10 – 5) % 3 ) * 4 + 9

La subexpresión (10 – 5) se evalúa primero, produciendo (7 * 5 % 3) * 4 + 9

A continuación se evalúa de izquierda a derecha la subexpresión (7 * 5 % 3) y obtenemos

(35 % 3) * 4 + 9 luego

2 * 4 + 9 donde se realiza la multiplicación y obtenemos 8 + 9 lo que produce un resultado final de 17.

Ejercicio 1.

A continuación se muestran expresiones algebraicas en base a las cuales usted deberá formular expresiones en C, utilizando los operadores aritméticos y tomando en cuenta la precedencia de operadores aritméticos.

1.) db+ac÷x+y 3.) d mod c (b + a) 5.) ax

2.) x+y ( m) n 4.) x + y + z ( w ÷ a) 6.) (x + y) dn

Ejercicio 2:

Si x=10, y=5 y z=1 encontrar el resultado de las siguientes expresiones:

a) x = y ______ b) z ≥ y ______ c) x ≤ y ________

Ejercicio 3:

Si x=2, y=1, c=4 y d=6 evalúe la expresión y diga el resultado.

A) x = y _____________ B) c ≠ d __________

Ejercicio 4. Evalúe las expresiones siguientes; use los mismos valores del ejemplo anterior:

A) ( y + 2 ) * c > = ( d + 1 ) * c R/ ______________

B) ( ( 2 / c ) * ( d / 2 ) ) + 5 < 10 R/ ______________

OPERADOR DE ASIGNACIÓN:

El operador = asigna el valor de la expresión derecha a la variable situada a su izquierda.

Ej. Pi = 3.1416
Raiz2 = 1.4142

Este operador es asociativo por la derecha, lo que permite realizar asignaciones múltiples. Así a = b = c = 45; equivale a a= (b = (c = 45)); en otras palabras, a, b y c toman el valor de 45.

Esta propiedad permite inicializar varias variables con una sola sentencia.

Int a, b, c;
A = b = c = 5;

TABLA DE OPERADORES DE ASIGNACIÓN:

Operadores de Incrementación y Decrementación

De las características que incorpora C, una de las más útiles son los operadores de incremento ++ y decremento -- . Los operadores ++ y --, denominados de incrementación y decrementación, suman o restan 1 a su argumento, respectivamente, cada vez que se aplican a una variable.

Entonces a++ equivale a a = a + 1

Estos operadores tienen la propiedad de que pueden utilizarse como sufijo o prefijo, el resultado de la expresión puede ser distinto, dependiendo del contexto.

Las sentencias ++n; y n++; tienen el mismo efecto; así como --n; y n--;

Sin embargo, cuando se utilizan como expresiones tales como

m = n++;

printf(“ n = %d”, n--) ; el resultado es distinto si se utilizan como prefijo.

++n produce un valor que es mayor en uno que el de n++, y --n produce un valor que es menor en uno que el valor de n--. Supongamos que

n = 8;

m = ++n; /* incrementa n en 1, dando 9, y lo asigna a m */

n = 9;

printf(“ n = %d”, --n); /*decrementa n en 1, dando 8 y lo pasa a printf( ) */

En este otro ejemplo:

int a = 1 , b;

b = a++; /* b vale 1 y a vale 2 */

int a = 1, b;

b = ++a; /* b vale 2 y a vale 2 */

Entonces, si los operadores ++ y -- están de prefijos, la operación de incremento o decremento se efectúa antes que la operación de asignación; si los operadores están de sufijos, la asignación se efectúa en primer lugar y la incrementación o decrementación a continuación.

Clase 2: Tipos de datos.

2007-07-08T17:00:00.000-07:00

Materia: Lógica Computacional
Profesor: Lic. Salomón Aquino.
Fecha: 09/07/07

Objetivos de la clase:
Al final de la clase los alumnos y alumnas serán capaces de:
1. Comprender y aplicar el concepto de datos
2. Comprender y aplicar lo operadores y conocer sus tipos.
3. Escribir expresiones con diferentes tipos de datos y operadores.

Conceptos:
DATO. Es la expresión general que describe los objetos con los cuales opera el programa. Por ejemplo, la edad y el domicilio de una persona, forman parte de sus datos.
Los datos se sitúan en objetos llamados variables.
Los tipos son: simples (no estructurados) y compuestos (estructurados).

Tipos de datos simples:

Tipos de datos compuestos:

Las Variables:
Las variables son zonas de memoria cuyo contenido cambia durante la fase de procesamiento de información. Son objetos cuyo valor puede ser modificado a lo largo de la ejecución de un programa.
Las variables llevan un nombre llamado Identificador. Este puede ser una cadena de letras y dígitos, empezando siempre con una letra. Por ejemplo: Pi, curso99, nom_alum, etc.
Los identificadores:
Los Identificadores son palabras creadas por los programadores para dar nombre a los objetos y demás elementos que necesitamos declarar en un programa: variables, constantes, tipos, estructuras de datos, archivos, subprogramas, etc.
En C++ las letras mayúsculas se tratan como diferentes y distintas unas de otras. Por ejemplo, contador, Contador y CONTADOR son tres nombres de identificadores distintos.
Un identificador no puede ser igual a una palabra reservada, y no debe tener el mismo nombre que una función, ya sea definida por el usuario o de la biblioteca de C.
Constantes, operador, expresiones:
Constantes: Son objetos cuyo valor permanece invariable a lo largo de la ejecución de un programa. Una constante es la denominación de un valor concreto, de tal forma que se utiliza su nombre cada vez que se necesita referenciarlo.
Un operador es un símbolo o palabra que significa que se ha de realizar cierta acción entre uno o dos valores que son llamados operandos.
Expresiones. Son representaciones de un cálculo necesario para la obtención de un resultado.
Son un conjunto de operadores y operandos que producen un valor. Por ejemplo:
Cos (pi * X) + 12.56 * SQR(100)
Tipos de operadores:
Aritméticos (su resultado es un número): potencia, * , / , mod, div, + , -
Relacionales (su resultado es un valor de verdad): =, <, >, <=, >=, <>
Lógicos o Booleanos (su resultado es un valor de verdad): not, and, or
Alfanuméricos : + (concatenación)
Asociativos. El único operador asociativo es el paréntesis ( ) , el cual permite indicar en qué orden deben realizarse las operaciones. Cuando una expresión se encuentra entre paréntesis, indica que las operaciones que están dentro de ellos debe realizarse
Operadores aritméticos:

Operadores de relación:

Operadores logicos:

Funciones predefinidas:

PRACTICA 1 : LOS ALGORITMOS

2007-07-02T20:10:00.000-07:00

Profesor: Lic. Salomón Aquino

Objetivos: Al final de la clase los alumnos y alumnas serán capaces de:
• Comprender y aplicar el concepto de algoritmos..
• Elaborar algoritmos narrados y en pseudocodigo.

Algoritmo: es una serie de operaciones detalladas a ejecutar paso a paso, que conducen a la resolución de problemas.
Es un conjunto de reglas para resolver determinado problema describiendo de forma lógica su solución.
Cada una de las acciones de que consta un algoritmo es denominada sentencia y éstas deben ser escritas en términos de cierto lenguaje comprensible para el computador, que es el lenguaje de programación.
Para diseñar un algoritmo se debe comenzar por identificar las tareas más importantes para resolver el problema y disponerlas en el orden en que han de ser ejecutadas.
Criterios que debe satisfacer un algoritmo (características):
1. Entrada. Son cero o más cantidades las cuales son externamente sustituidas.
2. Salida. Al menos una cantidad es producida.
3. Exactitud/precisión. Cada instrucción debe ser clara y sin ambigüedad.
4. Finito. Terminará después de un número finito de pasos.
5. Eficiente. Cada instrucción puede ser verificada por una persona con una prueba manual que satisfaga los requerimientos planteados por el problema.

Tipos De algoritmos:
a) Algoritmos Narrados.
b) Algoritmos enPseudocódigo

Algoritmos narrados: Este algoritmo es caracterizado porque sigue un proceso de ejecución común y lógico, describiendo textualmente paso a paso cada una de las actividades a realizar dentro de una actividad determinada.

Ejemplo 1 Algoritmo para asistir a clases:
1. Levantarse
2. Bañarse
3. Vestirse
4. Desayunar
5. Cepillarse los dientes
6. Salir de casa
7. Tomar el autobús
8. Llegar a la universidad.
9. Buscar el aula
10. Ubicarse en un asiento

Ejemplo 2 Receta para hacer huevos picados
1. Se coloca aceite o margarina en la cacerola
2. Se pica cebolla, chile y tomate
3. Se ponen a freír, con un poco de sal
4. Cuando ya están fritos, se echan los huevos
5. Se bate y se deja cocer
6. Se sirve caliente en un plato

Ejercicios:
Elabore un algoritmo narrado para los casos siguientes:
1. Cambiar un vidrio roto de una ventana
2. Preparar una taza de te
1. Hacer palomitas de maíz
4. Poner la mesa para la comida
5. Ir al cine

Algoritmos en Pseudocódigo
Pseudo = falso. El pseudo código no es realmente un código sino una imitación y una versión abreviada de instrucciones reales para las computadoras.
Es una técnica para diseño de programas que permite definir las estructuras de datos, las operaciones que se aplicarán a los datos y la lógica que tendrá el programa de computadora para solucionar un determinado problema.
Utiliza un pseudolenguaje muy parecido a nuestro idioma, pero que respeta las directrices y los elementos de los lenguajes de programación.
Se concibió para superar las dos principales desventajas de los flujogramas: lento de crear y difícil de modificar sin un nuevo redibujo.

Ejemplo 1
Diseñar un algoritmo que lea cuatro variables y calcule e imprima su producto, suma y media aritmética.
inicio
leer (a, b, c, d)
producto <-- (a * b * c * d)
suma <-- (a + b + c + d)
media <-- (a + b + c + d) / 4
escribir (producto, suma, media)
fin

Ejercicios:
1. Escribe un algoritmo que pida tres números y luego escriba el promedio.
2. Escribe un algoritmo que calcule el área de un círculo de cualquier radio.
3. Escribe un algoritmo que lea una cantidad depositada en un banco y que calcule la cantidad final después de aplicarle un 20% de interés.
4. Diseñar un algoritmo que lea un valor en dolares y lo convierta a colones salvadoreños.
5. Leer dos numeros y encontrar la suma del doble del primero mas el cuadrado del segundo.

Clase 1: Generalidades de la programación de computadoras. 01/07/08

2007-07-02T14:02:00.000-07:00

Objetivos de la clase:
• Al final de la clase los alumnos y alumnas serán capaces de:
– Comprender y aplicar los conceptos generales de la programación
– Aplicar el concepto de procesamiento de datos.
– Identificar la diferencia entre lenguajes de alto y bajo nivel.
– Definir y aplicar los conceptos de compiladores e intérpretes

Estructura de la clase:
• Conceptos básicos de programación.
• Los lenguajes de programación.

Conceptos básicos de programación:
• PROGRAMACION: Se llama programación a la creación de un programa de computadora
• PROGRAMA: Es un conjunto concreto de instrucciones que la computadora debe seguir para procesar datos y convertirlos en información.
• CARACTERISTICAS DE UN PROGRAMA:
– Debe ser confiable y funcional
– Advertir errores de entrada obvios y comunes
– Documentado adecuadamente
– Ser comprensible
– Codificado en el lenguaje apropiado
Conceptos básicos de programación:
• COMPUTADORA: Maquina electrónica que funciona casi a la velocidad de la luz y es capaz de procesar datos para convertirlos en información útil al ser humano.

Fig. 1 Procesamiento de datos.

Lenguajes de programación:
• Un lenguaje de programación es un lenguaje que puede ser utilizado para controlar el comportamiento de una máquina, particularmente una computadora. Consiste en un conjunto de reglas sintácticas y semánticas que definen su estructura y el significado de sus elementos, respectivamente.
• Un lenguaje de programación permite a un programador especificar de manera precisa: sobre qué datos una computadora debe operar, cómo deben ser estos almacenados y transmitidos y qué acciones debe tomar bajo una variada gama de circunstancias. Todo esto, a través de un lenguaje que intenta estar relativamente próximo al lenguaje humano o natural, tal como sucede con el lenguaje Lexico.
Lenguajes de alto y bajo nivel:
• lenguaje de bajo nivel
• Es el tipo de lenguaje que cualquier computadora es capaz de entender. Se dice que los programas escritos en forma de ceros y unos están en lenguaje de máquina, porque esa es la versión del programa que la computadora realmente lee y sigue.
• lenguajes de alto nivel
• Son lenguajes de programación que se asemejan a las lenguas humanas usando palabras y frases fáciles de entender.
• En un lenguaje de bajo nivel cada instrucción corresponde a una acción ejecutable por el ordenador, mientras que en los lenguajes de alto nivel una instrucción suele corresponder a varias acciones.
Ejemplo de Lenguaje de bajo nivel:

Ejemplo de lenguaje de alto nivel:

Interpretes y compiladores:
• Los compiladores, los intérpretes y los ensambladores se encargan de traducir lo que haya escrito en lenguaje de alto nivel (código fuente) y lo convierten a código objeto (casi ejecutable).

Tarea:
• Investigar sobre las generaciones de los lenguajes de programación.