Fundación Misión Sucre Colegio Universitario de Caracas
República Bolivariana de Venezuela Ministerio de Educación Superior Colegio Universitario de Caracas
Fundación Misión Sucre
Programa Nacional de Formación
en Sistemas e Informática
Introducción a la Programación
República Bolivariana de Venezuela Ministerio de Educación Superior Colegio Universitario de Caracas
Fundación Misión Sucre
*
Elaborado por:
Prof. Arrechedera Yoly Prof. Pérez Martha
Septiembre 2007
*
Contenido General
Descripción General ……….. 4 Objetivos Generales …...………… ………... 4 Duración ………... 4 Recursos Requeridos ………... 4 Taller 1: Programación Básica utilizando Lenguaje C ………... 5Taller 2: Estructuras de Datos Estáticas………... 36
Taller 3: Estructuras de Datos Dinámicas... 61
Anexos... 88
Descripción General
Introducción a la Programación, es una unidad curricular ubicada dentro del Programa Nacional de Formación en Sistemas e Informática, en el primer trayecto; se corresponde dentro de la estructura del programa en el espacio técnico, donde se ubican las unidades curriculares especializadas diseñado para adquirir los saberes contemplados en las competencias del profesional de sistemas.
Los Talleres de Introducción a la programación: 1. Programación Básica utilizando lenguaje C 2. Estructuras de Datos Estáticas
3. Estructuras de Datos Dinámicas
Forman parte de la estrategia Instruccional de la unidad curricular Introducción a la Programación y permitirán reforzar en los estudiantes los saberes relacionados con la técnicas computacionales, estructuras de datos y programación de las soluciones generadas, permitiéndole desarrollar actividades relacionadas con la programación en lenguaje C haciendo uso de las diferentes estructuras de datos.
Objetivos Generales
Al finalizar estos talleres, el estudiante estará en capacidad de: 1. Diseñar y Programar soluciones básicas utilizando lenguaje C.
2. Diseñar y programar en lenguaje C soluciones, utilizando estructuras de datos estáticas
3. Diseñar y programar en lenguaje C soluciones, utilizando estructuras de datos dinámicas
Duración
Taller de Programación Básica utilizando lenguaje C (Objetivo 1): 8 horas Taller de Estructura de Datos Estáticas (Objetivo 2): 8 horas
Taller de Estructura de Datos Dinámicas (Objetivo 3): 8 horas
Recursos Requeridos
Laboratorio de Computación. Materiales Instruccionales
Taller 1:
Programación Básica utilizando Lenguaje C
Objetivo
Diseñar y Programar soluciones básicas utilizando lenguaje C.
Contenido
Presentación del taller………. 6
Buenas Prácticas de Programación……….. 8
Conceptos a revisar………. 10
Desarrollo del Taller………. 13
Ejercicios……… 13
Presentación del taller
El taller de Programación Básica utilizando Lenguaje C, tiene como propósito que el estudiante consolide conocimientos fundamentales para la formación del pensamiento lógico computacional, con el uso de importantes construcciones de C, tales como los diferentes tipos de sentencias if, la función scanf, funciones iterativas como las sentencias de for yla sentencia de while entre otras.
Se enfoca en el análisis de programas y el desarrollo de ejercicios que brinden posibilidades de consolidar estos conocimientos básicos de la programación en C para ello se inicia con la introducción de las características que definen las buenas prácticas de programación, seguido de la presentación de los conceptos considerados de importancia revisar previamente a la realización de los ejercicios.
Los ejercicios presentados en este material están divididos en seis fases de desarrollo, que contemplan lo siguiente:
Fase 1: Se da un código fuente para que el estudiante pueda visualizar posibles errores que existen en el mismo.
Fase 2: Se presenta código fuente para que el alumno identifique variables y constantes en los programas.
Fase 3: El alumno correrá el programa “en frío” para saber que hace.
Fase 4: Se dan varios enunciados para que el estudiante realice la codificación del programa.
Fase 5: Se presenta un código desordenado para que los alumnos lo ordenen y busquen la solución más idónea.
Fase 6: Contiene las soluciones a los ejercicios presentados en las fases anteriores.
Para facilitar el uso de la guía de ejercicios se incluye una breve descripción de la simbología usada en su presentación.
Simbología a usar:
Fase 1: Buscar errores en el programa
Fase 2: Identificar variables y constantes en los programas.
Fase 3: ¿Que hace el programa?
Fase 4: Desarrollar programa
Fase 5: Ordenar programas
Buenas Prácticas de Programación
Se enumeran las prácticas consideradas como de “buen programador” haciendo referencia a características específicas del Lenguaje C.
1. Escriba sus programas con pasos sencillos y directos.
2. Coloque punto y coma (;) al final de cada sentencia.
3. Cada programa debe comenzar con un comentario que describa su propósito.
4. Muchos programadores hacen que el último carácter impreso por una función sea un salto de línea (\n) Esto asegura que la función dejará el cursor al inicio de una nueva línea.
5. Las variables globales deben definirse antes de la función main().
6. Establezca una convención para el tamaño de las sangrías y luego aplíquela de manera uniforme.
7. Declare las variables en líneas separadas ya que esto permite la fácil inserción de comentarios descriptivos junto a cada declaración. A excepción para algunas variables que tengan el mismo tipo de datos, sin excederse en el número de variables.
8. La declaración de variables con nombres significativos ayuda a que los programas estén auto documentados, es decir, que resulte más fácil entenderlos simplemente leyéndolos.
9. Como en álgebra, para hacer más clara a una expresión es aceptable agregarle paréntesis innecesarios. Dichos paréntesis se llaman paréntesis redundantes. Estos se emplean normalmente para agrupar subexpresiones de expresiones más grandes.
10. Sangre la instrucción del cuerpo de una estructura para que resalte la misma y así simplificar la lectura del programa.
12. Al escribir expresiones que contengan muchos operadores, consulte la tabla de precedencia de los operadores. Confirme que los operadores de la expresión se ejecutan en el orden que espera. Si no está seguro del orden de evaluación de una expresión compleja, coloque paréntesis para forzar el orden, justo igual como lo haría en una expresión algebraica.
13. Siempre ponga llaves en las estructuras if/else (y en cualquier
estructura de control) para ayudarle a evitar su omisión accidental, especialmente si después le agrega instrucciones a una cláusula if o else.
14. Coloque primero las llaves izquierda y derecha y después introduzca las instrucciones que van dentro de ellas. Con esto se evita la omisión de alguna de dichas llaves.
15. Inicialice los contadores y totales.
16. Utilice mensajes claros al pedir las entradas de teclado al usuario. Dicho mensaje debe especificar la forma de la entrada y los valores especiales que pueda tener.
17. Acostumbre a dar mensajes claros al efectuarse una operación del programa o al finalizar ya sean indicando el éxito o la falla del mismo.
18. Controle los ciclos con contadores por medio de variables enteras.
Conceptos a revisar
Recordemos que C es un lenguaje de programación creado en 1969, desarrollado y diseñado por Brian W. Kernighan y Dennis M. Ritchie. Se podría considerar como un Lenguaje de medio nivel, ya que no tiene comprobación estricta de tipos ni otras características que están presentes en los lenguajes de alto nivel.
Para abordar el presente taller hay que tener claro algunos conceptos y procedimientos:
Lenguaje de programación: Es un conjunto de palabras, reglas, con las cuales se le indica a la computadora las funciones que debe realizar.
Programa: Es un conjunto de instrucciones que se le dan a la computadora, para
que ésta realice una determinada tarea.
Pasos básicos para escribir un programa de computadoras en C:
Paso 1.- Leer y entender el contexto del problema que requiere una solución mediante un programa de computadora.
Paso 2.- Desarrollar un algoritmo para resolver el problema.
Paso 3.- Verificar su algoritmo para su validez.
Paso 4.- Convertir el algoritmo en lenguaje C.
Estructura de un Programa:
Cuando se escribe un programa en lenguaje C se recomienda usar el siguiente formato:
1.- Llamadas a bibliotecas. 2.- Declaración de funciones
3.- Declaración de variables globales. 4.- main()
{
5.- Declaración de variable locales 6.- Sentencias.
7.- }
8.- Definición de funciones
Etapas para obtener el programa ejecutable:
Un compilador: es un programa que convierte nuestro código fuente en un
compilador de línea de comando, al que tienes que llamar desde la línea de comandos del DOS.
Para escribir nuestros programas necesitamos un editor. La mayoría de los compiladores al instalarse incorporan ya un editor; es el caso de los conocidos Turbo C, Borland C, Visual C++,... Pero otros no lo traen por defecto. No debemos confundir por tanto el editor con el compilador. Si nuestro compilador no trae editor la solución más simple en MS-DOS puede ser usar el edit, en windows el notepad. Pero no son más que editores sin ninguna otra funcionalidad.
En los materiales proporcionados junto al taller se incluye una carpeta llamada COMPILADOR a la cual debes referirte en caso de que necesites instalarlo.
Bibliotecas: es el archivo que contiene código objeto de una colección de rutinas
o funciones que realizan tareas determinadas y se pueden utilizar en los programas.
Enlazador: Programa que convierte las funciones de la biblioteca estándar de C,
con el código que ha traducido el compilador.
Para la realización de los ejercicios utilizaremos el notepad++ como editor y el DJGCC como compilador, el cual usa los comandos del GCC.
Desarrollo del taller
Ejercicios
A continuación se presentan los ejercicios para el desarrollo del taller de programación básica utilizando lenguaje C. Recuerda revisar la simbología en la presentación del taller.
Ejercicio 1: #include <stdio.h> int main() { ClrScr(); gotoxy( 20, 10 )
printf( Encuéntrame en la fila 20 columna 10 ); return 0; } Ejercicio 2: #include <stdio.h> int main() { int número; número = 4; return 0;
Ejercicio 3: #include <stdio.h> int main() { int numero; numero = 4;
printf( "El valor es %d" Numero ); return 0; } Ejercicio 4: #include <stdio.h> int main() { int x, y; x = 6; y += x +5; }
Ejercicio 5: #include <stdio.h>
int main() {
int radio, perimetro; radio = 15;
perimetro = 2 * 3.1416 * radio;
printf( "El perímetro es: %d", perimetro ); return 0; } Ejercicio 6: #include <stdio.h> #define PI 3.1416 int main() {
int radio, perimetro; radio = 15;
perimetro = 2 * PI * radio;
printf( "El perímetro es: %d", perimetro ); return 0;
Ejercicio 7: #include <stdio.h> int main() { int x,y;
printf(“Ingrese dos numero enteros: \n”); scanf(%d %d,&x,&y);
printf(“Las entradas son: %d y %d\n”, x,y); if (x > y)
printf(“El máximo valor es: %d\n”, x); if (x < y)
printf(“El máximo valor es: %d\n”, y); if (x == y)
printf(“Los numeros son iguales\n”, x); }
#include <stdio.h>
int main() {
int y;
printf(“Ingrese un numero enteros: \n”); scanf(%d ,&y);
printf(“El numero es: %d\n”, y); if ( y % 2 == 0 ) printf( "%d es par\n", y ); else printf( "%d es impar\n", y ); printf( "\n" ); system( "pause" ); return 0; } Ejercicio 9:
int main() {
int i;
int numero, suma = 0; for ( i=0; i<5; i++ ); {
printf( "\nIntroduce un número: " ); scanf( "%d", &numero );
suma += numero; }
printf ( "\nTotal: %d\n", suma ); system( "PAUSE" ); } Ejercicio 10: #include <stdio.h> main() {
int numpers, i, sexo, contmax, confem; i=0;
contmax=0; confem=0;
printf("Ingrese el numero de personas a identificar: "); scanf(%d,&numpers);
while(i<numpers) {
printf("Cual es el sexo de la persona Nº %d?\n", i+1); printf("(1) Femenino, (2) Masculino: ");
scanf("%d",&sexo); if(sexo==1) confem++; if(sexo==2) contmax++; i++ }
printf("\n\t La cantidad de mujeres identificadas son: %d",confem ); printf("\n\t La cantidad de hombres identificados son: %d",contmax ); }
Ejercicio 11:
#include <conio.h> #include <stdio.h> int main()
int x, y, z; x = 5; y = ++x; z = ( x + 5 * 2 ) * ( y + 6 / 2 ) + ( x * 2 ); printf( "%d %d %d", x, y, z ); } Ejercicio 12: #include <stdio.h> int main() { int valor; valor = ( 5 * 30 * 100 ) * ( 1.12 ); printf( "El valor total es: %d", valor ); return 0;
}
Ejercicio 13:
/* Repetir un caracter un numero de veces */
#include <stdio.h> main()
{
printf("\nEscriba el caracter a repetir: "); scanf("%c",&ch);
printf("\nEscriba el numero de repeticiones: "); scanf("%d",&numero); while (numero>0) { printf("%c",ch); -- numero; } printf("\n"); } Ejercicio 14:
Borre la pantalla y escriba en la primera línea su nombre y en la segunda su apellido.
Ejercicio 15:
Borre la pantalla y muestre el texto "Bienvenidos al taller de programación" en la fila 15, columna 15 de la pantalla.
Ejercicio 16:
Que te imprima un mensaje de presentación, te pregunte como te llamas y te salude.
Que calcule el área de un triángulo rectángulo, dada la altura y la base.
Ejercicio 18:
Este programa comprueba la diferencia entre una variable global, una variable local y un argumento de función.
void suma2(int x) {
extern int vglobal; ++x;
++vglobal;
printf("\nLa variable vglobal dentro de suma2 vale = %d\n", vglobal); printf("\nEl argumento (vlocal) dentro de suma2 vale = %d\n", x); return;
}
=============================================================== main()
{
extern int vglobal; int vlocal=200;
printf("\nLa variable vglobal en main vale = %d\n", vglobal); printf("\nLa variable vlocal en main vale = %d\n", vlocal); suma1(vlocal);
=============================================================== /* Ejemplo de variable global, local y argumento de funcion */
declaracion en las funciones */ void suma1(int x);
void suma2(int x);
===============================================================
/* En salida no se ha modificado su valor pese a que en suma1 se hagan operaciones con vlocal (argumento) */
printf("\nLa variable vglobal despues de suma1 vale = %d\n", vglobal); printf("\nLa variable vlocal despues de suma1 vale = %d\n", vlocal); suma2(vlocal);
printf("\nLa variable vglobal despues de suma2 vale = %d\n", vglobal); printf("\nLa variable vlocal despues de suma2 vale = %d\n", vlocal); }
=============================================================== void suma1(int x)
{
extern int vglobal; ++x;
++vglobal;
printf("\nLa variable vglobal dentro de suma1 vale = %d\n", vglobal); printf("\nEl argumento (vlocal) dentro de suma1 vale = %d\n", x); return;
}
===============================================================
Ejercicio 19:
void lados() {
int y;
for (y=0; y<=FILAS; ++y) printf(" *\t\t\t\t\t\t\t\t\t\t*\n"); } =============================================================== lados(); linea(); printf("\n\n\n\n"); } =============================================================== void linea() { int x; printf(" ");
for (x=0; x<=ANCHO; ++x) putchar('*'); putchar('\n'); } =============================================================== main() { printf("\n\n\n\n"); linea(); lados(); printf(" *\t\t\t\t Programadores de C \t\t\t\t*\n"); ===============================================================
/* Mensaje rodeado por un borde */ #include <stdio.h> #define ANCHO 80 #define FILAS 6 void linea(); void lados(); ===============================================================
Soluciones
Ejercicio 1:
• ClrScr está mal escrito, debe ponerse todo en minúsculas.
• No se ha incluído la directiva #include <conio.h>, que necesitamos para usar clrscr() y gotoxy().
• Tampoco hemos puesto el punto y coma (;) después del gotoxy( 20, 10 ) Recordemos que después de cada instrucción debe ir un punto y coma. • El último fallo es que el texto del printf no lo hemos puesto entre comillas.
Lo correcto sería: printf( " Encuéntrame en la fila 20 columna 10" );
Ejercicio 2:
Los nombres de variables no pueden llevar acentos, luego al compilar número dará error.
Ejercicio 3:
Falta la coma después de "El valor es %d". Además la segunda vez numero está escrito con mayúsculas.
Ejercicio 4:
Cuando calculamos el valor de 'y' sumamos x+6 ( =10 ) al valor de 'y'. Pero resulta que 'y' no tenía ningún valor indicado por nosotros. Estamos usando la variable 'y' sin haberle dado valor. En algunos compiladores el resultado será inesperado.
Ejercicio 5:
Las constantes son aquellos datos que no pueden cambiar a lo largo de la ejecución de un programa.
radio y perimetro son variables, su valor puede cambiar a lo largo del programa. Sin embargo 15, 2 y 3.1416 son constantes, no hay manera de cambiarlas. El valor 3.1416 no cambia a lo largo del programa, ni entre ejecución y ejecución. Sólo cambiará cuando edites el programa y lo cambies tu mismo. Esto es obvio, y no tiene ningún misterio, así que no le des vueltas.
Ejercicio 6:
Constantes con nombrees PI que será sustituido por 3.1416 De esta forma cada vez que el compilador encuentre el nombre PI lo sustituye.
Supongamos que tenemos que hacer un programa en el que haya que escribir unas cuantas veces 3.1416 (que es igual a PI). Es muy fácil que nos confundamos alguna vez al teclearlo y al compilar el programa no tendremos ningún error, sin embargo el programa no dará resultados correctos. Para evitar esto usamos las constantes con nombre. Al definir una constante con nombre estamos dando un nombre al valor, a 3.1416 le llamamos PI.
Estas constantes se definen de la manera siguiente:
Se introduce dos números entero por teclado x e y. Se indica cual tiene el valor máximo.
Ejercicio 8:
Comprueba si un número es par o impar.
Para comprobar si un número es par o impar podemos usar el operador '%'. Si al calcular el resto de dividir un número por 2 el resultado es cero eso indica que el número es par. Si el resto es distinto de cero el número es impar.
Ejercicio 9:
El programa se ejecutará una única vez puesto que al final de la sentencia for hay un punto y coma. Como sabemos, el bucle for hace que se ejecuten las veces necesarias la sentencia siguiente (o el siguiente bloque entre {} ). Para que el programa funcione correctamente habría que eliminar el punto y coma.
Ejercicio 10:
El programa determina el sexo de un grupo de personas y lo muestra por pantalla
: Ejercicio 11 :
nota: (Falta correrlo)
Ejercicio 12: #include <stdio.h> #define CAJAS 5 #define UNIDADES_POR_CAJA 30 #define PRECIO_POR_UNIDAD 100 #define IMPUESTOS 1.12 int main() { int valor;
valor = ( CAJAS * UNIDADES_POR_CAJA * PRECIO_POR_UNIDAD ) * ( IMPUESTOS );
printf( "El valor total es: %d", valor ); return 0;
}
Ejercicio 13:
Este programa le pide al usuario un carácter y un número de repeticiones. Luego imprime el carácter el número de veces especificado.
#include <stdio.h> #include <conio.h> int main() { clrscr(); printf( "Carmen\n" ); printf( "Perez" ); return 0; }
También se podía haber hecho de otra manera ejemplo: #include <stdio.h> #include <conio.h> int main() { clrscr(); printf( "Carmen\nPerez" ); return 0; } Ejercicio 15: #include <stdio.h> #include <conio.h> int main() {
gotoxy( 15, 15 );
printf( " Bienvenidos al taller de programacion " ); return 0; } Ejercicio 16: #include <stdio.h> main() { char nombre[20];
printf("Hola, me llamo Ordenador, y tu?\n"); scanf("%s",&nombre[0]);
printf("Me alegro de conocerte %s\n",nombre); }
Ejercicio 17
/* Area de un triangulo rectangulo */ #include <stdio.h>
main() {
float altura, base; double area;
scanf("%f",&base);
printf("\nAltura del triangulo = "); scanf("%f",&altura);
area= 0.5 * (double) altura * base; printf("\nArea = %g\n",area); }
Ejercicio 18:†
Este programa comprueba la diferencia entre una variable global, una variable local y un argumento de función.
/* Ejemplo de variable global, local y argumento de funcion */
#include <stdio.h>
int vglobal=100; /* Se ve en todo el fichero y debe ir con extern dentro de la declaracion en las funciones */
void suma1(int x); void suma2(int x);
main() {
extern int vglobal; int vlocal=200;
printf("\nLa variable vglobal en main vale = %d\n", vglobal); printf("\nLa variable vlocal en main vale = %d\n", vlocal);
suma1(vlocal);
/* En salida no se ha modificado su valor pese a que en suma1 se hagan operaciones con vlocal (argumento) */
printf("\nLa variable vglobal despues de suma1 vale = %d\n", vglobal); printf("\nLa variable vlocal despues de suma1 vale = %d\n", vlocal); suma2(vlocal);
printf("\nLa variable vglobal despues de suma2 vale = %d\n", vglobal); printf("\nLa variable vlocal despues de suma2 vale = %d\n", vlocal);
}
void suma1(int x) {
extern int vglobal; ++x;
++vglobal;
printf("\nLa variable vglobal dentro de suma1 vale = %d\n", vglobal); printf("\nEl argumento (vlocal) dentro de suma1 vale = %d\n", x); return;
}
void suma2(int x) {
++x; ++vglobal;
printf("\nLa variable vglobal dentro de suma2 vale = %d\n", vglobal); printf("\nEl argumento (vlocal) dentro de suma2 vale = %d\n", x); return;
}
Ejercicio 19:
Programa que imprime un mensaje rodeado por un borde, utilizando funciones para dibujar los elementos del borde.
/* Mensaje rodeado por un borde */
#include <stdio.h> #define ANCHO 80 #define FILAS 5 void linea(); void lados(); main() { printf("\n\n\n\n"); linea(); lados(); printf(" *\t\t\t\t Bienvenido a C \t\t\t\t*\n"); lados(); linea();
} void linea() { int x; printf(" ");
for (x=0; x<=ANCHO; ++x) putchar('*'); putchar('\n');
}
void lados() {
int y;
for (y=0; y<=FILAS; ++y) printf(" *\t\t\t\t\t\t\t\t\t\t*\n"); }
