Apunte de Introduccion A La Programacion UBB

INTRODUCCIN A LA PROGRAMACIN
Claudio Gutirrez-Soto Manuel Crisosto Muoz
Introduccin a la Programacin Departamento de Sistemas de Informacin Universidad del Bo-Bo Agradecimientos
Quiero agradecer de manera anticipada a los alumnos de introduccin a la programacin, de quienes esperamos recibir feedback para mejorar este apunte con el objeto de que en algn momento sea un texto de apoyo a la programacin. Segundo, quiero agradecer a mi colega y amigo Manuel Crisosto quien ha hecho importantes contribuciones con ejemplos y ejercicios, as como tambin para que este apunte llegue a mano nuestros alumnos. Adems quiero agradecer a mis colegas Pedro Campos y Christian Vidal por sus aportes en la preparacin de los certamenes as como de las clases.
Claudio Gutirrez-Soto
Pgina : 2 Claudio Gutirrez-Soto, Manuel Crisosto,
Introduccin a la Programacin Departamento de Sistemas de Informacin Universidad del Bo-Bo
Prlogo Estimados alumnos, el material que se presenta a continuacin est diseado para apoyar la asignatura de introduccin a la programacin que tienen como objetivo el lograr resolver problemas simples mediante un programa escrito en algn lenguaje de programacin. Como ustedes pondrn ver el conjunto de smbolos, instrucciones y estructuras presentes en un algoritmo o programa son fciles de identificar y aprender en relacin a su significado. La dificultad se presenta al intentar combinar lgicamente estas instrucciones y estructuras para que resuelvan un problema planteado. El objetivo general es resolver problemas bsicos a travs de la construccin de programas basados en algoritmos. Un algoritmo lo podemos definir como un conjunto de pasos lgicamente ordenados, escritos a travs de smbolos o en lenguaje natural. Lo podemos comparar con una receta de cocina, o con las instrucciones para armar un mueble, las instrucciones que vienen en un manual de un grabador de CD, por mencionar algunos ejemplos. La diferencia est en la precisin que deben tener cada una de las instrucciones de un algoritmo. Por ejemplo, no podemos indicar en un algoritmo, agregue sal a gusto, o apret esta tuerca pues son indicaciones poco precisas, que no pueden ser traducidas a una instruccin escrita en un lenguaje de programacin. En el diseo e implementacin de los algoritmos debemos indicar agregue 10 grs. de sal, o apret esta tuerca dando diez giros a la derecha. Es decir las instrucciones dadas en un algoritmo deben de ser precisas y no ambiguas. En este material desde el primer captulo se presentarn una serie de ejercicios resueltos. Le recomendamos que antes de ver el desarrollo de estos ejercicios, intenten resolver dichos ejercicios. Es una tarea progresiva, que se puede apoyar si siguen los siguientes pasos: 1. Entender lo que se esta solicitando que el algoritmo o programa resuelva. ENTENDER EL ENUNCIADO. 2. La mayora de los algoritmos o programas requiere que se le ingresen datos que sern transformados, convenientemente por el conjunto de instrucciones, en la salida que se esta solicitando. Es imprescindible poder identificar estos datos de entrada y la informacin de salida que se est solicitando. 3. Identificar las posibles restricciones o condiciones que se deben consideran para los datos de entrada. 4. Construccin del algoritmo o programa. Sin embargo, lo ms importante que podemos recalcar en la utilizacin de este libro, es que la adquisicin de la destreza para poder resolver un problema a travs de un algoritmo es paulatina y progresiva. Es decir, hay que ejercitar con el objeto de adquirir la lgica para resolver problemas. Esto es equivalente a las metas de un deportista, ellos se colocan metas y trabajan constantemente para alcanzarlas. Aqu ocurre de manera similar, debemos de adquirir la destreza a travs de ejercicios. En dicho caso, nuestra herramienta es el computador, compilador y simuladores asociados.
Parte 0: Introduccin.............................................................................................................5 Programa ..........................................................................................................................5 Algoritmo ...........................................................................................................................6 Variables ...........................................................................................................................6 Concepto de Ciclo ..............................................................................................................13 Ciclo Mientras (expresin) ..............................................................................................13 Ciclo Repetir (instrucciones) Mientras ............................................................................13 Ciclo Para (variables de control): ....................................................................................14 Ejercicios parte 0: Construccin de algoritmos ...............................................................19 Parte 1: Estructura e instrucciones bsicas en el lenguaje C.............................................20 Funcin printf() ................................................................................................................20 Comentarios....................................................................................................................21 Define..............................................................................................................................24 Incremento y Decremento.............................................................................................24 Operadores .....................................................................................................................25 Ejercicios.........................................................................................................................26 Parte 2: Estructura de Control. ...........................................................................................28 La estructura de control if................................................................................................28 Proposicin switch ..........................................................................................................34 Proposicin while ............................................................................................................38 Ejercicios parte 2: Ciclo while .........................................................................................41 Proposicin for ................................................................................................................42 Ejercicios parte 2 ciclos for .............................................................................................45 Proposicin do while ......................................................................................................46 PREGUNTAS DE CERTAMENES DE AOS ANTERIORES al 2008, REFERENTES AL MANEJO DE CICLOS Y EVALUACIONES LGICAS ...................................................47 Parte 3: Definicin de una funcin......................................................................................51 Pasaje de parmetros o argumentos ..............................................................................59 PREGUNTAS DE CERTAMENES DE AOS ANTERIORES al 2008, REFERENTES AL MANEJO DE FUNCIONES .............................................................................................61 Parte 4: Arreglos Unidimensionales ...................................................................................65 Inicializacin de arreglos.................................................................................................65 Cadenas o Strings...........................................................................................................67 Arreglos bidimensionales ................................................................................................69 Ejercicios Parte 4: Arreglos.............................................................................................72 PREGUNTAS DE CERTAMENES DE AOS ANTERIORES al 2008, REFERENTES AL MANEJO DE ARREGLOS, CADENAS Y MATRICES....................................................74 Parte 5: Estructuras ............................................................................................................82 Declaracin de Variables de tipo estructura ...................................................................83 Referencia a los elementos de una estructura................................................................83 Arreglos de estructuras ...................................................................................................84 Estructuras en las funciones ...........................................................................................85 Estructuras como parmetros de una funcin ................................................................85 Ejercicios parte 5: Estructuras ........................................................................................86 Parte 6: Punteros................................................................................................................89 Uso de typedef....................................................................................................................94 Soluciones a ejercicios planteados.....................................................................................95
PARTE 0: INTRODUCCIN
Conceptos bsicos
PROGRAMA
Un programa computacional, en trminos simples, consiste en una serie de pasos lgicamente escritos que permiten resolver un problema determinado, que a partir de datos de entrada obtiene informacin til para la toma de decisiones. Aprender a programar consiste, por un lado, en conocer las distintas instrucciones que un determinado lenguaje de programacin tiene, y ms importante an, escribir un conjunto de instrucciones en forma lgica para que la ejecucin de estas instrucciones permita dar respuesta al problema planteado. No basta con conocer las instrucciones existentes, se debe adquirir la lgica que permite utilizarlas con un fin especfico. La mayora de los problemas que se resuelven en el transcurso de un curso de programacin viene especificada mediante un enunciado. Los pasos necesarios para poder construir un programa que de respuesta al enunciado lo podemos resumir de la siguiente manera: Entender el problema Buscar soluciones Elegir solucin Disear solucin Implementar solucin Validar solucin La siguiente figura simplifica los pasos anteriores, para esto supongamos que queremos construir un programa que permita resolver la ecuacin de primer grado.
Programa que permite resolver la ecuacin de primer grado
ax+b=0 a b
a0
Algoritmo EC 1er Grado Variables a,b,x de tipo entero Inicio Escribir(Ingrese valores de EC) Leer (a,b) Si a = 0 entonces escribir (Error) sino Inicio x=-b/a Escribir (La solucin es:,x) Fin Escribir(Fin programa) Fin
x= -b / a
#include <stdio.h> int a,b,x; main() { printf(Ingrese valores de EC); scanf(%d %d,&a,&b); if a ==0 printf (error); else { x = -b / a; printf(La solucin es %d:,x); } printf(Fin programa); }
El primer paso es entender que se est pidiendo, esto requiere de la mxima atencin, pues de lo contrario difcilmente el programa escrito responder al enunciado planteado. Una vez que se entiende el enunciado se debe poder definir cuales son los datos de entrada del programa y cual es la informacin de salida. Adems, se debe poder definir algunas restricciones, para este ejemplo que a debe ser distinto de cero. A continuacin se recomienda escribir un algoritmo que represente una aproximacin a la solucin final. Posterior a estos pasos se traduce el algoritmo a un lenguaje de programacin determinado.
ALGORITMO
Un algoritmo consiste en un procedimiento detallado, escrito en forma simblica o con lenguaje natural, para resolver un problema en pasos y en un tiempo finito. Algunas caractersticas de los algoritmos son: el algoritmo lleva desde un estado inicial a un estado final se especifican en base a operaciones bsicas que controlan las variables y el flujo del algoritmo el algoritmo recibe entradas y entrega salidas
VARIABLES
En todo programa computacional se requiere almacenar temporalmente datos en posiciones especficas de la memoria del computador. Estos datos pueden ser ingresados por ejemplo desde teclado (datos de entrada), o ser datos intermedios producto de alguna transformacin (procesamiento) para producir la salida requerida (informacin). Los lenguajes de programacin utilizan diversos tipos de datos los cuales determinan la cantidad de memoria a ocupar en el computador. Entre estos datos tenemos:

Tipo de dato Entero Real o flotante Lgico Carcter Propsito Permite almacenar valores de tipo entero. Permite almacenar nmeros fraccionarios. Permite almacenar los valores lgicos de verdad, Verdadero o Falso. Permite almacenar cualquier carcter conocido.
Para hacer uso de las posiciones de memoria donde se almacenan los datos se utilizan etiquetas o nombres. La etiqueta o nombre es un nemotcnico que se recomienda que sea significativo para el dato que se esta almacenando. Por ejemplo: si se requiere almacenar la suma de varios valores, conviene bautizar la posicin de memoria con el nombre suma, si se quiere calcular la ecuacin de primer grado, los datos de entrada conviene almacenarlos en las posiciones con nombre a, b; y el resultado de la evaluacin en x. Recordemos que para resolver un problema, se debe tener claro cuales son los datos de entrada y salida; adems de estos se pueden utilizar datos intermedios necesarios para el procesamiento. Todos estos datos se deben declarar, al inicio del programa o, como veremos ms adelante, al inicio de cada seccin del programa.

La forma en que se ejecutan las operaciones bsicas en un computador, es similar a lo que ocurre en nuestro cerebro. Por ejemplo, para sumar dos valores, los pasos bsicos son: Primero debemos pedirle a alguien que nos diga el primer valor. Luego de que conocemos este valor, debemos almacenarlo (para recordarlo despus) en una neurona (Suponemos que un valor se puede almacenar en una neurona). Ya conocemos el primer valor y est almacenado en nuestro cerebro. Ahora debemos pedir el segundo valor. Una vez conocido, lo almacenamos en otra neurona distinta de la anterior. Por qu se debe hacer esto?: Si almacenamos el valor en la misma neurona no recordaremos el primer valor a sumar. Ahora que conocemos los dos valores procedemos a sumarlos, y dicho resultado lo almacenamos en otra neurona distinta de las anteriores. Por ltimo, le decimos el resultado a la persona que nos entrego los nmeros. De lo anterior podemos decir que: al menos necesitamos 3 neuronas para sumar dos nmeros. pedimos explcitamente que nos dijeran dichos valores. asignamos dichos valores a las neuronas la suma la realiz nuestro cerebro de forma mecnica. Finalmente se da el resultado Por lo tanto el algoritmo bsico para sumar dos nmeros podra ser el siguiente: Algoritmo para sumar dos nmeros: o Definimos tres neuronas o Pedimos el primer valor o Almacenamos ese valor en la neurona 1. o Pedimos el segundo valor o Almacenamos ese valor en la neurona 2. o Almacenamos la suma de las neuronas 1 y 2 en la neurona 3 o Entregamos el resultado que se encuentra en la neurona 3. En los algoritmos y lenguajes de programacin no se usan neuronas, pero podemos definir variables (recuerde que las variables pueden tomar cualquier valor segn el tipo de dato definido), es decir, en lugar de usar neurona 1 y neurona 2, se utilizan espacios de memoria que llamaremos var 1 y var 2, y as sucesivamente. Tambin las podemos llamar x1 y x2 x e y. Recuerde que es conveniente usar nombre de variables que de alguna forma reflejen el contenido de dicha posicin de memoria.
Ejercicio 0.1: Cree un algoritmo que multiplique tres nmeros.

Datos de Entrada: nmeros (x1,x2,x3) Informacin de Suma de x1,x2 y x3 tres Algoritmo para multiplicar tres nmeros: Definimos cuatro variables var1, var2, var3 y var4 de tipo entero Pedimos el primer valor Almacenamos ese valor en var1. Pedimos el segundo valor Almacenamos ese valor en var2. Pedimos el tercer valor Almacenamos ese valor en var3. Almacenamos la multiplicacin de las variables en var4 Entregamos e l resultado que se encuentra en var4.
Salida:
Restricciones: Ninguna

La manera en que se han detallado los dos algoritmos se llama pseudo-cdigo, el cual fue escrito en lenguaje natural (nuestro lenguaje, entendible por el ser humano). Otra manera de poder detallar lo algoritmos, es a travs de los diagrama de flujo. Un diagrama de flujo es una representacin simblica de la lgica del algoritmo. Existen un conjunto de smbolos bsicos utilizados en la constriccin de diagramas de flujo, los cuales tienen su equivalente en pseudo-cdigo, y lo ms importante su correspondiente traduccin en un lenguaje de programacin.
DIAGRAMA DE FLUJO Inicio NOMENCLATURA Inicio de Algoritmo PSEUDO-CDIGO Inicio Variables Entero var1, x, y Real a, b
Entero var1, x , y Real a, b Escribir Mensaje 1
Definicin de variables
Impresin de mensajes
Escribir (Mensaje 1)
Leer var1,x, y
Lectura de mensajes Transformacin de datos Operaciones sobre los datos
Leer (var1, x, y)
a=3*x+ y b = a / var1
a=3*x+ y b = a / var1 Si a > b Entonces Inicio Instrucciones Fin Sino Inicio Instrucciones Fin Fin
Si a > b
Bifurcacin en la ejecucin de instrucciones
Conector
Fin
Fin de algoritmo
Como hemos mencionado anteriormente, no basta con saber el significado de cada smbolo, debemos saber como combinar estos smbolos para producir un algoritmo que resuelva el problema planteado.
Introduccin a la Programacin Departamento de Sistemas de Informacin Universidad del Bo-Bo Ejemplo 0.2: El siguiente algoritmo, escrito utilizando diagrama de flujo permite sumar dos nmeros y
muestra el resultado por pantalla (o monitor) Entrada: Dos nmeros (x1 y x2) Salida: x1+x2 Restricciones: Ninguna Inicio int var1,var2 ,var3
Ingrese el primer valor
var 1
En pseudos-cdigo: Algoritmo Suma Variables Entero var1, var2, var3 Inicio Escribir(Ingrese el primer valor) Leer (var1) Escribir(Ingrese el segundo valor) Leer (var2) var3=var1+var2 Escribir(El resultado es:,var3) Fin
Ingrese el segundo valor
El lenguaje C:
var 2 #include<stdio.h> int var1,var2,var3; main() { printf(Ingrese el primer valor:); scanf(%d,&var1); printf(Ingrese el segundo valor:); scanf(%d,&var2); var3=var1+var2; printf(El resultado es:%d,var3); }
var3=var1+var2
El resultado es : var3
Termino
Observacin: En los ejemplos de este apartado, incluiremos el cdigo en lenguaje C con el objetivo de que lo prueben, modifiquen, adapten, corrijan, etc.
Ejemplo 0.3: Cree un algoritmos donde una persona ingrese su edad y muestre por pantalla
si es mayor de edad. Entrada: Edad Salida: Mensaje 1: Usted es mayor de edad Mensaje 2: Usted es menor de edad (slo uno de estos mensajes) Restricciones: Edad no puede ser negativa, ni mayor a 200 (esto no es validado en este algoritmo).
En pseudos-cdigo: Algoritmo Edad Variables Entero edad Inicio Escribir(Ingrese su edad:) Leer (edad) Si (edad >= 18) Entonces Inicio Escribir(Usted es mayor de edad) Fin Sino Inicio Escribir(Usted es menor de edad) Fin Fin El lenguaje C: #include<stdio.h> int edad; main() { printf(Ingresesu edad:); scanf(%d,&edad); if (edad >= 18) { printf(Usted es mayor de edad); } else { printf(Usted es menor de edad); } }
Inicio
Entero Edad
Ingrese su edad
Edad
Edad >= 18
Usted es mayor de edad
f
Usted es menor de edad
Termino
Del ejemplo anterior podemos observar que la bifurcacin permite seguir el flujo adecuado dada una condicin. La condicin que se evalan en una bifurcacin puede ser verdadera o falsa y determina el conjunto de instrucciones que se ejecutaran. No siempre es necesario colocar instrucciones en el caso de que la condicin sea falsa, esto depender del problema que se este resolviendo. Tambin es posible que existan bifurcaciones contiguas.

En las bifurcaciones o estructura de control, se evalan proposiciones utilizando: Operadores lgicos: And, or y not Operadores aritmticos: *, / , +, - , %1 Operadores Relacionales: == (igual), != (distinto), > (mayor que), < (menor que), >= (mayor igual), <= (menor igual) Recordemos que los operadores lgicos estn definidos segn el algebra booleana y arrojan un valor de verdadero o falso segn las proposiciones que forman la expresin. La siguiente tabla de verdad nos muestra las posibles combinaciones que se puede presentar (supongamos que las proposiciones son P1 y P2). (P1) V V F F (P2) V F V F (P1) and (P2) V F F F (P1) or (P2) V V V F Not (P1) F F V V
Adems, cada expresin puede estar formada por una o ms proposiciones unidas por operadores lgicos, a estas expresiones les llamaremos expresiones compuestas. Ejemplo 0.4: Evaluacin de una expresin compuesta Asumamos la siguiente expresin: ((P1 and P2) or P3) and (not P3)) Para determinar la veracidad o falsedad de esta expresin debemos saber el valor de verdad de cada proposicin, la cual puede cambiar en el transcurso del tiempo. La tabla de verdad asociada a esta expresin se forma a partir de todas las posibles combinaciones:
P1 P2 P3 P1 and P2 (P1 and P2) or P3 Not P3 ((P1 and P2) or P3) and (not P3))
V V V V F F F F
V V F F V V F F
V F V F V F V F
V V F F F F F F
V V V F V F V F
F V F V F V F V
F V F F F F F F
Hasta ahora los algoritmos descritos son secuenciales, es decir se ejecuta una instruccin, y al trmino de sta se ejecuta la siguiente, excepto cuando existe una bifurcacin, en cuyo caso se podra saltar un grupo de instrucciones dependiendo de la evaluacin de la condicin. El control de ejecucin es siempre hacia delante. Existen aplicaciones en las cuales se requiere repetir un nmero determinado de instrucciones, en cuyo caso, una o ms instrucciones se ejecutarn de acuerdo a determinadas condiciones, a estas estructuras presentes en los algoritmos se les denomina ciclos.
Corresponde a la funcin modulo que entrega el resto de la divisin entre dos enteros.
CONCEPTO DE CICLO
Un ciclo es la repeticin de un conjunto de instrucciones. Dicho ciclo culmina cuando se cumple una condicin de trmino. El grupo de instrucciones se pueden ejecutar un nmero conocido o desconocido de veces.
CICLO MIENTRAS (EXPRESIN): Esta estructura se utiliza cuando se quiere repetir un conjunto de instrucciones mientras se cumpla una determinada condicin la cual es evaluada al comienzo del ciclo. El grupo de instrucciones se ejecutar como mnimo cero veces (la expresin evaluada es falsa), o una o ms veces (la expresin evaluada es verdadera, y se espera que esta cambie en el transcurso de la ejecucin del grupo de instrucciones)2. En el diagrama de flujo se utiliza la estructura de bifurcacin, y cuando termina de ejecutarse el grupo de instrucciones, el control del algoritmo retorna a la bifurcacin, producindose una nueva evaluacin de la expresin. El esquema siguiente ilustra la forma que toma este ciclo utilizando diagrama de flujo y pseudoscdigo.
Instruccin a
Instruccin a F mientras (expresin) Inicio Instruccin 1 Instruccin 2
expresin V Instruccin 1 Instruccin 2
Instruccin N
Instruccin n Fin Instruccin b
Instruccin b
Ciclo Mientras
CICLO REPETIR (INSTRUCCIONES) MIENTRAS

La diferencia con el ciclo anterior es que la expresin se evala al trmino de la ejecucin del grupo de instrucciones que se necesitan repetir, tal como lo muestra el esquema siguiente. Si esto no se cumple, es decir la expresin inicialmente es verdadera y no cambia se producira un ciclo infinito o loop infinito.
2
Instruccin a
Instruccin a do Inicio Instruccin 1 Instruccin 2
Instruccin 1 Instruccin 2
Instruccin N V Instruccin n Fin mientras (expresin) Instruccin b
expresin F Instruccin b
Ciclo Repetir . Mientras

En las estructuras anteriores el nmero de veces que se repetirn las instrucciones no necesariamente es conocido (esto depende la lgica del algoritmo). Existen muchas ocasiones en que se conoce el nmero de veces que se desea repetir el grupo de instrucciones, por ejemplo leer 100 nmeros. En estos casos es aconsejable utilizar el ciclo Para.
CICLO PARA (VARIABLES DE CONTROL): En este ciclo el nmero de veces que se repite el conjunto de instrucciones es conocido, y el control de la repeticin es asumido por un conjunto de variables de control. El esquema siguiente representa esta estructura en diagrama de flujo y pseudos-cdigo. Las variables de control se inicializan en un determinado valor, el cual aumenta o disminuye de acuerdo un salto definido, hasta llegar a un valor final.

Instruccin a Vc = Vi , Vf / Condicin, Salto
Instruccin a Para ( Vc=Vi; Vf / Condicin; Salto) Inicio Instruccin 1 Instruccin 2
Instruccin 1 Instruccin 2
Instruccin N Fin
Instruccin n
Instruccin b
Instruccin b
Ciclo Para (variables de control)

A continuacin de vern algunos ejemplos para clarificar estas estructuras.
Ejemplo: Construir la tabla de multiplicar de un numero ingresado por teclado, partiendo desde cero. Entrada: x Salida: x*0, x*1, x*2, x*3..x*x Restricciones: No tiene
Inicio
Entero a,b
Escribir Ingrese un numero entero:
Leer (a)
Algoritmo Tabla de Multiplicar Variables Entero a,b Inicio Escribir (Ingrese un nmero entero:) Leer (a) b=0 Para (b=0; b<a; salto 1) Inicio Escribir (a,b,a*b) Fin Fin #include <stdio.h> Int a, b; main() { printf(Ingrese un nmero entero:); scanf(%d,&a); for(b=0;b<a;b=b+1) { printf(%d * %d = %d,a,b,a*b); } }
b0
b=0,b<a, inc 1
Escribir a, b, a*b
Fin

Observacin: Revisar este algoritmo y realizar un seguimiento. Qu sucede cuando se ingresa un nmero negativo. El algoritmo: es una respuesta al enunciado planteado?. Realice las modificaciones que estime necesarias. En el ejemplo anterior, la variable de control b se inicializa en 0 (b=0) y el grupo de instrucciones (en este caso una instruccin) se ejecuta mientras se cumpla la condicin que b sea menor que a (b<a). Cada vez que se ejecuta el grupo de instrucciones el valor de b se incremente en 1 (inc 1). Algunas caractersticas del ciclo Para: El incremento puede ser un valor negativo o positivo, entero o decimal, unitario o no unitario. La expresin adems de la variable de control puede contener ms proposiciones, esto depender de la lgica del programa. Es aconsejable no modificar el valor de estas variables en el grupo de instrucciones que se repiten. Para un problema pueden existir varias posibles soluciones. Analicemos el siguiente ejemplo: Construir un programa que permita evaluar la siguiente funcin para un rango de valores enteros de x comprendido en el intervalo [a,b]. f(x)= (3x2+5x-2)/125 Se debe mostrar en pantalla el valor de x y f(x). Entrada: a, b Salida: f(a), f(a+1), f(a+2)f(b-2), f(b-1), f(b) Restricciones: a < b
Inicio
Inicio
Entero a,b,x Real fx
Entero a,b,x Real fx
Escribir Ingrese los valores de a y b
Escribir Ingrese los valores de ay b
Leer (a,b)
Leer (a,b)
Si a < b
Si a > b
Escribir a debe ser menor que b
F x=a,x<=b, inc 1 x=a,x<=b, inc 1
fx = (3*x*x+5*x-2) / 125 fx = (3*x*x+5*x-2) / 125
Escribir x, fx
Escribir x, fx
Fin
Fin
La primera solucin muestra un mensaje al usuario indicando que al ingresar un intervalo [a,b], siempre a debe ser menor que b y se termina el programa, en este caso el usuario deber ejecutar nuevamente el algoritmo. La segunda solucin valida que el valor de a sea menor que b, permitiendo ingresar varias veces el valor de a y b, hasta que a sea menor que b. A continuacin se escribe los pseudo-cdigo de ambos diagramas de flujo y sus correspondientes programas en C.
Introduccin a la Programacin Departamento de Sistemas de Informacin Universidad del Bo-Bo Uso de bifurcacin y ciclo para
Algoritmo F(x) Variables Entero a,b,x Real fx Inicio Escribir(Ingrese los valores de a y b) Leer (a,b) Si (a<b) entonces Inicio Para (x=a, x<=b, inc 1) Inicio fx = (3*x*x+5*x-2) / 125 Escribir ( x, fx) Fin Fin Si no Inicio Escibir(a debe ser menor que b) Fin Fin
Uso de repetir mientras y ciclo para

Algoritmo F(x) Variables Entero a,b,x Real fx Inicio Escribir(Ingrese los valores de a y b) Repetir Inicio Leer (a,b) Fin Mientras (a > b) Para (x=a, x<=b, inc 1) Inicio fx = (3*x*x+5*x-2) / 125 Escribir ( x, fx) Fin Fin
Equivalente en lenguaje C
#include<stdio.h> int a,b,x; flota fx; main() { printf(Ingrese los valores de a y b); scanf(%d,&a); scanf(%d,&b); if (a<b) { for (x=a;x<=b;x=x+1) { fx= (3*x*x+5*x-2) / 125; printf(%d %f, x,fx); } } else { printf(a debe ser menor que b) } } #include<stdio.h> int a,b,x; flota fx; main() { printf(Ingrese los valores de a y b); do { scanf(%d,&a); scanf(%d,&b); } while (a>b) for (x=a;x<=b;x=x+1) { fx= (3*x*x+5*x-2) / 125; printf(%d %f, x,fx); } }
EJERCICIOS
PARTE
0: CONSTRUCCIN
DE ALGORITMOS3
Construya los siguientes algoritmos 1. Que multiplique tres nmeros ingresados desde teclado y muestre el resultado 2. Que divida dos nmeros y muestre el resultado 3. Que muestre en forma ordenada tres nmero enteros ingresados desde teclado. 4. Que resuelva la ecuacin de primer grado y muestre el resultado 5. Que resuelva la ecuacin de segundo grado, para valores reales e imaginarios, y muestre el resultado. 6. Que permita sumar n nmeros y muestre el resultado. El valor de n debe ser ingresado por teclado al igual que los nmeros que se sumarn. 7. Que permita el ingreso de 15 nmeros y que cuente cuntos de los nmeros ingresados son pares. 8. Que permita el ingreso de 15 nmeros y que muestre el mayor, el menor y el promedio. 9. Crear un algoritmo donde el usuario ingrese Crear un algoritmo que reciba a>=0 y b>=0 y que calcule: a!/((a-b)!b!) Construya los algoritmos que permitan calcular las siguientes series con un valor de n ingresado desde teclado 10. 12+22+32+ +N2 11. 1!+2!+3!++N! 12. 11+22+33+ +NN 13. -11+22-33+..+Nn, tal que N es par 14. (1+1)+(2+(1+2))+(3+(1+2+3))+(N+(1+2+N)) 15. (1!+2!+3!++N!)/(1+2+3++N) 16. 11+(21+22)+(31+32+33)++(N1+N2++NN) 17. 11!+(21!+22!)+(31!+32!+33!)++(N1!+N2!++NN!) 18. 1N+2N-1+3N-2+.+N1
No se incluirn las respuestas de este apartado.

PARTE 1: ESTRUCTURA E INSTRUCCIONES BSICAS EN EL LENGUAJE C

La siguiente es la estructura general de un programa en C #include<stdio.h> main() { printf (Este es mi primer programa en C); getchar(); } En este sencillo ejemplo, podemos visualizar lo siguiente: #include<stdio.h> Esto hace referencia a la librera stdio.h, la cual posee las funciones de entrada y salida de datos. Existen mltiples libreras para propsitos especficos. main(), es la funcin principal de C, ella siempre debe main() estar presente. Comienza el cuerpo del programa { printf(Este es mi primer programa en C.); La funcin printf( ), se encarga de mostrar o desplegar el contenido que se encuentra entre las comillas en el monitor. Funcin que espera a que se presione una tecla getchar(); Fin del programa. } Este programa debe ser compilado para su ejecucin. El proceso de compilacin, en trminos simples, corresponde a la traduccin del programa fuente a su equivalente en lenguaje objeto o lenguaje de mquina. El compilador realiza un anlisis sintctico del programa. Una vez compilado, arrojar en pantalla: Este es mi primer programa en C. Ejemplo 1.1 En pantalla : #include<stdio.h> main() { printf(hola mundo.); } Hola mundo.
FUNCIN
PRINTF()
La funcin printf( ), consta de dos partes : cadena de control y una lista de argumentos. En el siguiente ejemplo veremos como se utiliza los caracteres de control.

Ejemplo 1.2 : En este ejemplo se muestran las diferentes cadenas de control para la funcin printf #include<stdio.h> main() { printf(Ahora utilizaremos los caracteres de control\n); printf(El siguiente carcter salta a una nueva lnea. \n); printf( \t El carcter utilizado es un tabulador. \n); printf( \ Esta frase esta entre comillas. \ \n); printf( El siguiente carcter representa retorno de carro : \r \n); printf( \ Esta frase esta entre apstrofes. \ \n); printf( \\ Esta frase esta entre barras invertidas \\ \n); printf(Los siguientes caracteres representan retrocesos :\b\b\b\b\b\b \n); } A continuacin se imprimir lo siguiente en pantalla: Ahora utilizaremos los caracteres de control El siguiente carcter salta a una nueva lnea El carcter utilizado es un tabulador. \ Esta frase esta entre comillas. \ El siguiente carcter representa retorno de carro Esta frase esta entre apstrofes. \ \\ Esta frase esta entre barras invertidas \\ Los siguientes caracteres representan retrocesos :
COMENTARIOS
Los comentarios son una lista de caracteres desconocidos por el compilador, que tienen como objetivo fundamental el hacer referencias, documentacin o acotaciones a lneas de cdigos o al programa general, la forma de utilizarlos es: /* Este es un comentario, el cual generalmente involucra 2 o ms lineas de cdigo */ // Este es otro comentario que involucra 1 sola lnea de comentario Ahora veremos como se utilizan la lista de argumentos del printf( ). Ejemplo 1.3: Aqu se muestran los diferentes caracteres (argumentos) asociados a los tipos de datos para su correspondiente impresin. #include<stdio.h> Se imprimir lo siguiente en pantalla: main() { El valor del entero es : 1 int entero=1; // declaracin de una variable entera El valor del flotante es : 1.56356789; // llamada entero, con valor 1. El valor del carcter es : a float comaflotante =1.56356789; Esta es una cadena char caracter=a; char cadena[]= Esta es una cadena; printf(El valor del entero es : %d \n, entero); printf(El valor del flotante es : %f \n, comaflotante); printf(El valor del carcter es : %c \n, caracter); printf( %s \n, cadena);

getchar(); } En el ejemplo anterior podemos ver los caracteres de control %d, %f, %c y %s, los cuales aparecen dentro de los printf. Estos son utilizados para imprimir variables de acuerdo al tipo de dato que dichas variables almacenan. CARCTER c d s e f g TIPO DE DATO Carcter Entero String (conjunto de caracteres) Flotante en notacin cientfica Flotante e f ms corto.
Otro ejemplo, donde podemos utilizar las opciones de visualizacin de las variables, es el siguiente Ejemplo 1.4 #include<stdio.h> main() { float i=56.111111111; printf(El valor de i es : %f printf(El valor de i es : %5f printf(El valor de i es : %15f printf(El valor de i es : %.1f printf(El valor de i es : %.5f printf(El valor de i es : %.0f printf(El valor de i es : %e getchar(); } Se imprimir lo siguiente en pantalla : El valor de i es : 56.111111 El valor de i es : 56.111111 El valor de i es : 56.111111 El valor de i es : 56.1 El valor de i es : 56.11111 El valor de i es : 56 El valor de i es : 5.61111e+01
\n,i); \n,i); \n,i); \n,i); \n,i); \n,i); \n,i);
Ejemplo 1.5: En este ejemplo se muestran los caracteres de control, salto de lnea, retoceso y tabulacin. #include<stdio.h> main() { printf(Estos han sido unos \EXCELENTES EJEMPLOS\ \n); printf( \t \b\b\b\b\b *** \n); printf( *** ); printf( *** ); printf( *** ); printf( \t \b\b\b\b\b *** \n); } Esto imprimir lo siguiente : Estos han sido unos EXCELENTES EJEMPLOS *** *** *** *** ***

Entre otras caractersticas del printf( ), podemos encontrar. Ejemplo 1.6: Aqu se muestra que es posible realizar las operaciones matemticas bsicas dentro del printf. #include<stdio.h> main() { int a, b; a=3; b=4; printf(La suma de la variable a+b es : %d. \n, a+b); } Funcin scanf() El scanf( ) es la funcin que permite recibir datos ingresados a travs de teclado. Ejemplo 1.7: La funcin scanf tambin utiliza caracteres para los distintos tipos de datos. Obsere que son los mismos caracteres que utiliza la funcin printf. #include<stdio.h> #include<conio.h> //librera que contiene la funcin clrscr( ). main() { int a,b; printf(Ingrese el primer valor a sumar\n); scanf( %d, &a); printf(Ingrese el segundo valor a suma \n); scanf( %d, &b); printf(El resultado de a+b es : %d \n, a+b); getchar(); } En este ejemplo es posible notar que a las variables a y b en la funcin scanf se le antepone el signo &. El signo & es utilizado por el compilador para guardar los valores que se le asignan a las variables en las correspondientes direcciones de memoria de dichas variables. Por lo tanto, cada vez que utilizamos scanf, las variables debern llevar el & en el argumento de la funcin (osea despus de la coma). Como en el ejemplo, scanf( %d, &a); Ejemplo 1.8 Aqu se muestra que tambin es posible ingresar varios datos a la vez con la funcin scanf. #include<stdio.h> #include<conio.h> main() { int a; float b; char c; printf(Ingrese un entero, luego un flotante y por ltimo un carcter \n); printf( todos separados por un espacio \n); scanf(%d %f %c, &a,&b,&c); printf(Los valores ingresados fueron : %d, %f, %c \n, a,b,c); } Esto imprimir : La suma de la variable a+b es : 7.
DEFINE
El uso de define, se utiliza para declarar variables con un valor fijo (tambin denominada constante), el cual puede ser utilizado en el resto del programa. Las lneas de control con #define se pueden presentar de varias formas. Por ejemplo: #define STRING "Este es un ejemplo" #define SEGUNDOS_AL_DIA (60 * 60 * 24) En este ejemplo, el valor (60 * 60 * 24) reemplazar a SEGUNDOS_AL_DIA por ese string todas las veces que aparezca en el resto del archivo. Un error frecuente es terminar una lnea #define con un punto y coma, lo cual la convierte en parte de la cadena de reemplazo, cuando esto no es lo que se desea. Los #define sencillos tienen varios usos importantes que mejoran la claridad y la transportabilidad de los programas. Por ejemplo, para constantes especiales : #define PI 3.14159 #define E 2.71828 /* exponencial */ #define C 299792.4562 /*velocidad de la luz en km/seg*/ En trminos generales, las constantes simblicas ayudan en la documentacin al reemplazar lo que de otra forma sera una constante enigmtica con un identificador nemotecnico, hacen ms porttil el programa al permitir que se alteren en un solo lugar las constantes que pueden ser dependientes del sistema, y mejoran la confiabilidad al restringir a un solo lugar la verificacin de la representacin real de la constante. Ejemplo 1.9: Ingresar el valor del radio para calcular el rea de una circunferencia. #include<stdio.h> #include<conio.h> #define PI 3.1415
// se define una constante simblica.
main() { float radio; printf(Ingrese el radio \n); scanf(%f,&radio); printf(El rea del crculo es : %f \n, PI * radio * radio); getchar(); } El programa del ejemplo calcular el rea del crculo, reemplazando PI, por el valor flotante 3.1415
INCREMENTO
DECREMENTO
En C, existen los operadores matemticos de incremento y decremento, los cuales aumentan y disminuyen el valor actual de una variable en 1. El operador de incremento es : ++ El operador de decremento es: --

Ejemplo 1.10 Aqu se muestra la aplicacin del incremento y decremento de variables #include<stdio.h> main() { int i=0, j=1; i++; j--; printf(El valor de i es : %d. \n,i); printf(El valor de j es : %d. \n,j); getchar(); }
Esto imprimir : El valor de i es : 1 El valor de j es : 0
Ejemplo 1.11 En este ejemplo se muestra la diferencia de aplicar los operadores de incremento antes y despus de la variable. #include<stdio.h> main() { int i=2,j=2,a,b; a=-2*i++; b=-2*++j; printf(El valor de a es: %d y el de i es: %d \n,a,i); printf(El valor de b es: %d y el de j es: %d \n,b,j); getchar(); }
Imprimir en pantalla lo siguiente: El valor de a es : -4 y el de i es: 3 El valor de b es : -6 y el de j es: 3
De lo anterior nos podemos dar cuenta que existe un orden de precedencia de los operadores de incremento y decremento, es decir, no entregan el mismo resultado al colocarlos antes o despus de las variables que se incrementan o decrementan.
OPERADORES
++ (incremento) * (multiplicacin) +(suma) = (asignacin) -- (decremento) / (divisin) (resta) - (unario) %(mdulo)
Como mencionamos previamente, existe una diferencia entre : ++i; otros operadores de incremento y decremento.
y i++; al momento de utilizar
La operacin de modulo (a % b) entrega el resto de la divisin entre los enteros a y b.
EJERCICIOS
Crear los siguientes programas: 1. 2. 3. 4. 5. Ingresar dos nmeros y multiplicarlos. Ingresar el radio de una circunferencia y calcular su permetro. Ingresar el largo y ancho de un rectngulo y calcular el rea y permetro. Ingresar el radio y el alto para obtener el volumen de un cilindro. Ingresar cuatro nmeros, obtener la suma, multiplicacin y promedio.

Dado los siguientes cdigos: 6. Qu errores presenta el siguiente programa? #include<stdio.h> main() { int a, b; printf(Ingrese el primer nmero \n); scanf(%c,&a); printf(Ingrese el segundo nmero \n); scanf(%c,&d); } 7. Qu sucede en el siguiente programa? #include<stdio.h> main() { float a,b; printf(Ingrese el primer valor \n); scanf(%f,&a); printf(Ingrese el segundo valor \n); scanf(%f,&b); suma= a+b; printf(El resultado es %d \n, suma); return(); }
PARTE 2: ESTRUCTURA DE CONTROL.

Las estructuras de control permiten romper el orden lineal de ejecucin de las instrucciones (una a continuacin de la otra), permitiendo bifurcar en dos o ms caminos la ejecucin de las instrucciones, o repetir un nmero conocido o desconocido de veces un conjunto de instrucciones. En estas estructuras se utilizan (expresiones) formadas por operadores relacionales y operadores lgicos. Operadores Relacionales Menor < Mayor > Menor o igual <= Mayor o igual >= Igual == Distinto != Operadores Lgicos Negacin ! && Y lgico O lgico ||
LA
ESTRUCTURA DE CONTROL IF
La estructura de control if permite bifurcar la ejecucin de instrucciones en dos caminos Sintaxis : if (expresin) sentencia V // se ejecutan estas sentencias si evaluacin de la expresin es verdadera else sentencia F // se ejecutan estas instrucciones si la evaluacin de la expresin es falsa donde: expresion TipoOperador Proposicion1 TipoOperador Proposicion2 TipoOperador ....ProposicionN Operador lgico OperadorMatemtico OperadorRelacional.
Ejemplo 2.1: Ingrese 2 nmeros y muestre la divisin : Entrada: a y b Salida : a/b Restricciones: b 0 #include<stdio.h> void main() { float a,b; printf(Ingrese el primer valor \n); scanf(%f,&a); printf(Ingrese el segundo valor \n); scanf(%f,&b); if(b!=0) printf(El resultado es %f \n,a/b); else print(El resultado no existe \n);

} En este ejemplo comenzamos a utilizar la proposicin if. Dentro de esta proposicin nos encontramos con el operador lgico distinto !=, ya que como sabemos cualquier nmero dividido por cero es indeterminado. Resumiendo, si el divisor es distinto de cero, se har la divisin, en caso contrario desplegar el mensaje El resultado no existe. Algunas veces no es necesario la sentencia else, como se ve en el siguiente ejemplo. Ejemplo 2.2 Aqu se muestra un ejemplo donde se calcula el sueldo lquido de una persona. Sin embargo, si la persona es de la I o XII regin, esta recibe el 35% de su sueldo por zona. Es posible apreciar que no es necesario la sentencia else, es decir con la sentencia if se modifica lo necesario y se sigue el curso normal del programa. Entrada: Sueldo Bruto Salida : Sueldo Liquido Restricciones: no tiene #include<stdio.h> main() { float sueldoB,AFP,ISAPRE; int region; printf(Ingrese su sueldo Bruto \n); scanf(%f,&sueldoB); printf(Ingrese la region donde trabaja \n); scanf(%d,&region); if (region==1 || region==12) // si la persona pertenece a la primera duodcima sueldoB=sueldoB*1.35; // regin se le aumenta un 35% de su sueldo bruto AFP= sueldoB*0.07; // se calcula el 7% de la AFP ISAPRE=sueldoB*0.11; // se calcula el 11% de la Isapre printf( El sueldo lquido es de: %f \n, sueldoB-AFP-ISAPRE); } Algunas veces se necesitar tener varios if anidados. La sintaxis de estos es la siguiente : If(expresion1) else if(expresion2) else if(expresion3) else if(expresion4) else expresion 5 Ejemplo 2.3 En este ejemplo se muestra si un nmero es par o imparr, para ello se utiliza el operador mdulo %. Entrada: X Salida : Mensaje 1: El nmero es par Mensaje 2: El nmero es impar Restricciones: no tiene #include<stdio.h> main() { int numero; printf(Ingrese un nmero \n); scanf(%d,&numero); if(!(numero%2))

printf(El nmero es par \n); else printf(El nmero es impar \n); } Cualquier nmero par, al dividirlo por 2 su residuo es 0., es decir el mdulo es 0. Ejemplo 2.4 En este ejemplo se ingresan tres nmeros y se muestra el mayor, para ello se utiliza la sentencia if-else anidadas. Entrada: a,b,c Salida : se imprime el mayor Restricciones: no tiene #include<stdio.h> main() { int a,b,c; printf(Ingrese el primer nmero \n); scanf(%d, &a); printf(Ingrese el segundo nmero \n); scanf(%d, &b); printf(Ingrese el tercer nmero \n); scanf(%d, &c); if(a>b) if(a>c) printf(El nmero mayor es %d \n,a); else printf(El nmero mayor es %d \n,c); else if(b>c) printf(El nmero mayor es %d \n,b); else printf(El nmero mayor es %d \n,c); } Ejemplo 2.5 En este ejemplo se ingresan tres nmeros y se muestra el mayor, para ello se utiliza la sentencia if else anidados, en conjunto con el operador lgico y ( &&). Entrada: a,b,c Salida : se imprime el mayor Restricciones: no tiene #include<stdio.h> main() { int a,b,c; printf(Ingrese el primer nmero \n); scanf(%d, &a); printf(Ingrese el segundo nmero \n); scanf(%d, &b); printf(Ingrese el tercer nmero \n); scanf(%d, &c); if(a>b && a>c) printf(El numero mayor es %d \n,a); else if(b>c) printf(El nmero mayor es %d \n,b); else printf(El nmero mayor es %d \n,c); getchar();

} Ejemplo 2.6 En este ejemplo se ingresa un nmero entero y se muestra el valor absoluto de dicho nmero. Entrada: x Salida : Valor absoluto de x Restricciones:no tiene #include<stdio.h> main() { int x; printf(Ingrese un nmero \n); scanf(%d, &x); if(x>0) printf(El valor absoluto de %d es %d \n,x,x); else printf(El valor absoluto de %d es %d \n,x,(-1*x)); getchar(); } Ejemplo 2.7 En este ejemplo se ingresan tres nmeros y de ellos se muestran el mayor y menor de los tres. Entrada: a,b,c Salida : se imprime el mayor y el menor Restricciones: no tiene #include<stdio.h> main() { int a,b,c,min,max; printf(Ingrese el primer nmero \n); scanf(%d, &a); printf(Ingrese el segundo nmero \n); scanf(%d, &b); printf(Ingrese el tercer nmero \n); scanf(%d, &c); if(a>b && a>c) max=a; else if(b>c) max=b; else max=c; if(a<b && a<c) min=a; else if(b<c) min=b; else min=c; printf(El nmero mayor es %d y el menor es %d n, max,min); }
Ejemplo 2.8 Este ejemplo al igual que el anterior, se ingresan tres nmeros y se muestran el mayor y el menor. Entrada: a,b,c Salida : se imprime el mayor y el menor Restricciones: no tiene #include<stdio.h> main() { int a,b,c,min,max; printf(Ingrese el primer nmero \n); scanf(%d, &a); printf(Ingrese el segundo nmero \n); scanf(%d, &b); printf(Ingrese el tercer nmero \n); scanf(%d, &c); if(a>b && a>c) { max=a; if(b>c) min=c; else min=b; } else if(b>c) { max=b; if(c>a) min=a; else min=c; } else { max=c; if(b>a) min=a; else min=b; } printf(El nmero mayor es %d y el menor es %d n, max,min); }

Ejemplo 2.9 Este ejemplo muestra la solucin para la ecuacin cuadrtica. Aqu se utiliza la librera math.h, la cual contiene la funcin sqrt. La funcin sqrt calcula la raz cuadrada de un valor. Entrada: a,b,c Salida : x1 y x2 (las soluciones de la ecuacin) Restricciones: a 0 b2-4ac 0 #include<stdio.h> #include<math.h> void main() { float a,b,c,dis; float x1,x2; printf(Ingrese a \n); scanf(%f, &a); printf(Ingrese b \n); scanf(%f, &b); printf(Ingrese c \n); scanf(%f, &c); dis=b*b-4*a*c; // aqu se calcula el discriminante if(dis<0 || a ==0) // si el discriminante es menor que cero, entonces se trata de complejos printf(No se puede calcular \n); else { x1= (-b+sqrt(dis))/(2*a); x2= (-b-sqrt(dis))/(2*a); printf(El valor x1 y x2 son : %d, %d \n,x1,x2); } } Ejemplo 2.10 En este ejemplo se ingresan valores nmericos del 0 al 9. Y dicho valor es desplegado de manera textual. Aqu se utilizan varios if-else anidados. Entrada : x Salida : x escrito en palabra Restricciones: 0 x 9 #include<stdio.h> void main() { int valor; printf(Ingrese un nmero del 0-9 \n); scanf(%d,&valor); if(valor >=0 && valor <=9) if(valor==1) printf(El nmero ingresado es el uno \n); else if(valor==2) printf(El nmero ingresado es el dos \n); else if(valor==3) printf(El nmero ingresado es el tres \n); else if(valor==4) printf(El nmero ingresado es el cuatro \n); else if(valor==5) printf(El nmero ingresado es el cinco \n);

else if(valor==6) printf(El nmero ingresado es el seis \n); else if(valor==7) printf(El nmero ingresado es el siete \n); else if(valor==8) printf(El nmero ingresado es el ocho \n); else printf(El nmero ingresado es el nueve \n); else printf(El valor ingresado esta fuera del rango \n); }
PROPOSICIN
SWITCH
switch es una proposicin condicional mltiple que generaliza a la proposicin if-else. Lo siguiente es la estructura del switch switch (expresin) { case 'caso_1': sentencias; break; case 'caso_2': sentencias; break; case 'caso_3': sentencias; break; case 'caso_N': sentencias; break; default: sentencias; } Obsrvese que la proposicin switch est encerrada entre llaves. Despus de evaluar la expresin, el control salta a la etiqueta apropiada (al correspondiente case). Todos los case son exclusivos, es decir reflejan un caso particular. Por lo comn, la ltima proposicin antes de la siguiente case es break. Con este break nos aseguramos que la ejecucin del caso termine all. Si no hay una proposicin break, la ejecucin hasta el siguiente case que sigue. La ausencia de proposiciones break es una causa frecuente de error en el uso de switch. Por ltimo, puede haber una proposicin etiquetada default. Esto indica que si la evaluacin de switch no coincide con ninguna etiqueta, entonces toma en cuenta el default.

Ejemplo 2.11: Crear un programa donde el usuario pueda ingresar dos valores y opta por sumar, restar, dividir multiplicar dichos valores, utilizando switch. Entrada : x1,x2, opcin Salida : x1 opcin x2 Restricciones: no tiene #include<stidio.h> void main() { float a,b,c; int opcion,div0=0; printf("Ingrese a \n"); scanf("%f",&a); printf(" Ingrese b \n"; scanf("%f",&b); printf("Ingrese 1 suma, 2 resta, 3 divisin 4 multiplicacin \n"); scanf("%d",&opcion); if(b==0.0 && opcion==3) opcion=5; switch(opcion) { case 1 : c=a+b; break; case 2: c=a-b; break; case 3: c=a/b; break; case 4: c=a*b; break; case 5 : div0=1; break; default: div0=-1; } if(div0 == 1) printf("Division por cero no se puede calcular \n"); else if(div0==-1) printf("Ingreso una opcion no valida \n"); else printf(" El resultado es : %f \n",c); getchar(); } Notar que los valores adjuntos al lado derecho de los case de este ejemplo, van sin . Esto porque los valores que se estn evaluando corresponde a enteros y no a caracteres.

Ejemplo 2.12 Crear un programa donde el usuario pueda ingresar dos valores y opta por sumar, restar, dividir multiplicar dichos valores, utilizando switch. Pero a diferencia del ejemplo anterior, aqu se utiliza una variable denominada bandera, la cual nos indica si es posible mostrar el resultado (en el caso de una divisin por cero, esto no es posible). Entrada : x1,x2, opcin Salida : Mensaje 1: x1 opcin x2 Mensaje 2: No se puede dividir por cero (en caso que se quiera dividir dos nmeros) Restricciones: Si se divide, x2 no puede ser cero No se puede ingresar una opcin distinta a las ofrecidas #include<stidio.h> main() { float a,b,c, int opcion,bandera=1; printf("Ingrese a \n"); scanf("%d",&a); printf(" Ingrese b \n"; scanf("%d",&b); printf("Ingrese 1 suma, 2 resta, 3 divisin 4 multiplicacin \n"); scanf("%d",&opcion); switch(opcion) { case 1 : c=a+b; break; case 2: c=a-b; break; case 3: if(b!=0.0) c=a/b; else bandera=-1; break; case 4: c=a*b; break; default: bandera=0; } if(bandera==1) printf(" El resultado es : %d \n",c); else if(bandera==0) printf("Ingreso una opcin no valida \n"); else printf("No se puede dividir por 0 \n"); }

Ejemplo 2.13: Crear un programa donde el usuario ingrese un nmero del 1 al 9, y se muestre en pantalla el texto asociado al nmero, pero utilizando la proposicin switch. Entrada : x Salida : x escrito en palabra Restricciones: 0 x 9 #include<stdio.h> main() { int valor; printf(Ingrese un nmero del 0-9 \n); scanf(%d,&valor); switch(valor) { case 1 : printf(El nmero ingresado es el uno \n); break; case 2: printf(El nmero ingresado es el dos \n); break; case 3: printf(El nmero ingresado es el tres \n); break; case 4: printf(El nmero ingresado es el cuatro \n); break; case 5: printf(El nmero ingresado es el cinco\n); break; case 6: printf(El nmero ingresado es el seis\n); break; case 7: printf(El nmero ingresado es el siete \n); break; case 8: printf(El nmero ingresado es el ocho \n); break; case 9: printf(El nmero ingresado es el nueve \n); break; default: printf("Ha ingresado un valor no vlido \n"); } getchar(); }

Ejemplo 2.13: Crear un programa donde el usuario pueda ingresar dos valores y optar por sumar, restar, dividir multiplicar dichos valores utilizando switch. A diferencia de los ejemplos anteriores, aqu seleccionamos la operacin con caracteres. Entrada : x1,x2, opcin Salida : Mensaje 1: x1 opcin x2 Mensaje 2: No se puede dividir por cero (en caso que se quiera dividir dos nmeros) Restricciones: Si se divide, x2 no puede ser cero No se puede ingresar una opcin distinta a las ofrecidas #include<stidio.h> main() { float a,b,c, char opcion; int bandera=1; printf("Ingrese a \n"); scanf("%f",&a); printf(" Ingrese b \n") scanf("%f",&b); printf("Ingrese S suma, R resta, D divisin M multiplicacin \n"); scanf("%c",&opcion); switch(opcion) { case 'S' : c=a+b; break; case 'R': c=a-b; break; case 'D': if(b!=0.0) c=a/b; else bandera=-1; break; case 'M': c=a*b; break; default: bandera=0; } if(bandera==1) printf(" El resultado es : %d \n",c); else if(bandera==-1) printf("No se puede calcular la division \n"); else printf("Ingreso una opcin no vida \n"); }
PROPOSICIN
WHILE
Es una construccin de la forma: while (expresin) proposicin(es) a repetir proposicin que no se repite

Primero se evala expresin; si es falso (o es el valor cero), el control pasa directamente a proposicin siguiente (proposicin que no se repite), pero si es verdadero (o el valor es distinto de cero), entonces se ejecuta (proposicin a repetir), y el control se devuelve al principio del ciclo while. De este modo, proposicin se ejecuta cero (a expresin es falsa en la primera evaluacin) o varias veces hasta que expresin sea falsa, en ese momento, el control pasar a la proposicin que no se repite. El efecto de esto es que la proposicin puede ejecutarse cero, una o ms veces. Es posible que, sin advertirlo, se especifique una expresin que nunca se convierta en falsa (o cero), y con esto el programa quedar en un ciclo infinito a menos que se introduzcan medios para escapar del ciclo while; para evitar tal situacin debe tenerse cuidado. Ejemplo 2.14: Crear un programa que calcule el factorial de un nmero que sea un entero mayor o igual que cero. Entrada : x Salida : 1*2*3*4*5..*x (si x>0) 1 (si x=0) Restricciones: x 0 #include<stdio.h> main() { int contador,numero,fact=1; printf(Ingrese el nmero para calcular el factorial \); scanf(%d,&numero); if(numero >0) { contador=numero ; while(contador) { fact=fact*contador; contador--; } printf(El factorial de %d es %d \n,numero,contador); } else if(numero==0) printf(El factorial de 0 es 1 \n); else printf(los factoriales de nmeros negativos no existen \n); } Ejemplo 2.14:Una alternativa al problema anterior #include<stdio.h> main() { int contador,numero,fact=1; printf(Ingrese el nmero para calcular el factorial \); scanf(%d,&numero); if(numero >0) { contador=1 ; while(contador<=numero) { fact=fact*contador; contador=contador+1; } printf(El factorial de %d es %d \n,numero,contador); } else if(numero==0) printf(El factorial de 0 es 1 \n); else printf(los factoriales de nmeros negativos no existen \n); getchar();

} Ejemplo 2.15: Crear un programa que resuelva lo siguiente: 1+2+3+4+5+6+7+8+...+n Entrada : n Salida : 1+2+3+4+5+..+(n-1)+n Restricciones: n > 0 #include<stdio.h> main() { int contador,n,suma; printf(Ingrese el nmero para calcular la sumatoria \n); scanf(%d,&n); if(n>0) { for(contador=1,suma=0;contador<=n ; contador++) suma=suma+contador; printf(El resultado de la sumatoria es %d \n,suma); } else printf(El nmero que ingreso es incorrecto\n); getchar(); }
Ejemplo 2.15: Cree un programa que calcule ab, donde a >0 y b>0
Entrada : a,b Salida : ab Restricciones: a>0 y b>0 #include<stdio.h> main() { int contador,a,b,pot; printf(Ingrese la base\n); scanf(%d,&a); printf(Ingrese el exponente \n); scanf(%d,&b); if(a>0 && b>0) { contador=1: pot=1; while(contador<=b) { pot=pot*a; contador=contador+1; } printf(El resultado de %d elevado a %d es %d \n,a,b,pot); } else printf(Hay un nmero que no es mayor que 0 \n); getchar();
}
Nota: modificar este programa para que a y b acepte cualquier valor entero (positivo, negativo o cero).
EJERCICIOS
PARTE
2: CICLO
WHILE
1.- Crear un programa que calcule: 12+22+32+42+...+n2 2.- Crear un programa que calcule : (n)= 11+22+33+44+...+nn 3.- Crear un programa que calcule: 1!+2!+3!+4!+...+n! 4.- Crear un programa que calcule. 10+21+32+43+54 +...+Nn-1 5.- Crear un programa donde se ingresen 15 nmeros y muestre el mayor de todos. 6.- Crear un programa donde se ingresen 20 nmeros y muestre el mayor y el menor. 7.- Crear un programa que calcule: (a b)= a!/(b!-a!). 8.- Crear un programa donde se ingresen 15 nmeros y contar cuantos son pares. 9.- Analizar el siguiente programa. #include<stdio.h> main() { int valor,contpares=0,i; i=50000; while(i); i--; printf( Fin del programa \n); }
10.- Analizar el siguiente programa. #include<stdio.h> main() { int i; i=1; while(i) printf( El valor de i es : %d\n",i); i++; }
PROPOSICIN
Sintaxis:
FOR
for (expresin1 ; expresin2 ; expresin3) proposicin verdadera; proposicin siguiente; o for (expresin1 ; expresin2 ; expresin3) { proposicin verdadera1; proposicin verdadera2; . proposicin verdaderaN; } proposicin siguiente; Primero se evala expresin1 (lo usual es que expresin1 inicie el ciclo); despus, se evala expresin2, si la expresin 2 es verdadera (o posee un valor distinto de 0) entonces se ejecuta la proposicin verdadera o el conjunto de expresiones verdaderas. Note que el conjunto de expresiones verdaderas est compuesto por ms de una expresin verdadera y por lo tanto debe de llevar las llaves { }. Posterior al ejecutar la proposicin o proposiciones verdades, entonces se ejecuta la expresin 3, la cual generalmente aumenta o disminuye la variable, o variables que condicionan el ciclo. Posteriormente se vuelve a evaluar la expresin2, si esto es verdadero se vuelve a ejecutar la proposicin o conjunto de proposiciones verdaderas, donde posteriormente se evalua la expresin3. Note que la expresin1, slo se ejecuta la primera vez, luego la expresin2 y expresin3 se peueden ejecutar muchas veces mientras la expresin 2 sea verdadera. Finalmente, si la expresin2 es falsa (o posee un valor 0), entonces se ejecuta la proposicin siguiente. Ejemplo 2.16 Este ejemplo imprime valores desde 1 al 15, utilizando el ciclo for #include<stdio.h> #define STOP 15 main() { int i; for(i=1;i<=STOP;i++) printf(El valor de i es:%d\n,i); getchar(); }
Introduccin a la Programacin Departamento de Sistemas de Informacin Universidad del Bo-Bo Ejemplo 2.17: Crear un programa que calcule el factorial de un nmero que sea un entero
mayor que cero. Entrada : x Salida : 1*2*3*4*5..*x (si x>0) 1 (si x=0) Restricciones: x 0 #include<stdio.h> main() { int contador,numero,fact=1; printf(Ingrese el nmero para calcular el factorial \n); scanf(%d,&numero); if (numero >0) { for( contador=numero ; contador ; contador--) fact=fact*contador; printf(El factorial de %d es %d \n,numero,fact); } else if (numero==0) printf(El factorial de 0 es 1 \n); else printf(los factoriales de nmeros negativos no existen \n); }
Ejemplo 2.18: Crear un programa que resuelva lo siguiente: 1+2+3+4+5+6+7+8+...+n , utilizando ciclos for Entrada : n Salida : 1+2+3+4+5+..+(n-1)+n Restricciones: n > 0 #include<stdio.h> main() { int i,n,suma=0; printf(Ingrese el nmero para calcular la sumatoria \n); scanf(%d,&n); if(n>0) { for(i=1,suma=0;i<=n ; i++) suma=suma+i; printf(El resultado de la sumatoria es %d \n,suma); } else printf(El nmero que ingreso es incorrecto\n); }
Ejemplo 2.19: Cree un programa que calcule ab, donde a >0 y b>0
Entrada : a,b Salida : ab Restricciones: a>0 y b>0 #include<stdio.h> main() { int i,a,b,pot; printf(Ingrese la base\n); scanf(%d,&a); printf(Ingrese el exponente \n); scanf(%d,&b); if(a>0 && b>0) { for(i=pot=1; i<=b; i++) pot=pot*a; printf(El resultado de %d elevado a %d es %d \n,a,b,pot); } else printf(Hay un nmero que no es mayor que 0 \n); }
Ejemplo 2.20: Crear un programa que calcule: 11+22+33+44+...+nn Entrada : n Salida : 11+22+33+44+...+nn Restricciones: n > 0 #include<stdio.h> void main() { int contador,N,b,pot; printf(Ingrese N\n); scanf(%d,&N); if(N>0 ) { for(i=1;i<=N;i++) { for(j=pot=1; j<=i ; j++) pot=pot*a; suma=suma+pot; } printf(El resultado es. %d \N,suma); } else printf(el nmero ingresado no es mayor que 0 \n); }
EJERCICIOS
PARTE
CICLOS FOR
Utilizando el ciclo for construya los siguientes programas

11. Calcular lo siguiente : 1+2+3+4+5+...+N 12. Calcular 12+22+32+42+...+N2 13. Crear un programa que calcule: 10+21+32+43+...+NN-1 14. Crear un programa que calcule: 11+22+33+44+..+Nn 15. Crear un programa que calcule lo siguiente: 1!+2!+3!+4!+...+N! 16. Crear un programa que calcule: a b= a!/b!(b-a)! 17. Crear un programa que calcule lo siguiente: (a k)=s(s-1)(s-2)(s-3)(s-4)...(s-k+1)/k! (a 0)=1 s R+, k N U{0} 18. Crear un programa que calcule: 1(x1+1)/1!+2(x2+1)/2!+3(x3+1)/3!+...+N(xN+1)/N! 19. Crear un programa que calcule lo siguiente: n 3* i 2*i-1/(n-i)! i=1
20. Crear un programa que calcule lo siguiente: n i ( (2*i)/j ) i=1 j=1 21. Crear un programa que calcule: n i (2*j)i i=1 j=1 22. Crear un programa donde se ingresen 50 nmeros, muestre el mayor, menor, y cuantos de ellos son mltiplos de 5.
PROPOSICIN
DO WHILE
Este es un ciclo como los anteriores, pero la principal diferencia es que este se ejecuta al menos una vez. Sintaxis: do { sentencia_1; sentencia_2; : sentencia_N; } while(proposicion); Ejemplo 2.21: Crear un programa donde el usuario ingrese 2 nmeros y pueda ejecutar cualquiera de las operaciones basicas. Si se desea salir se debe ingresar 0. Entrada : x1,x2, opcin Salida : Mensaje 1: x1 opcin x2 Mensaje 2: No se puede dividir por cero (en caso que se quiera dividir dos nmeros) Restricciones: Si se divide, x2 no puede ser cero No se puede ingresar una opcin distinta a las ofrecidas #include<stdio.h> main() { float a,b,c; int opcion; do { printf("Ingrese el Primer Valor \n"); scanf("%f",&a); printf("Ingrese el segundo Valor \n"); scanf("%f",&b); printf("Ingrese 1:sumar, 2:restar ,3:dividir,4:mutiplicar \n") ; scanf("%d",&opcion); if (b!=0.0 && opcion==3) opcion=5; switch(opcion) { case 1: printf("El resultado es : %f \n",a+b); break; case 2: printf("El resultado es : %f \n",a-b); break; case 3: printf("El resultado es : %f \n",a/b); break; case 4: printf("El resultado es : %f \n",a*b); break; case 5: printf("No se puede dividir por cero \n"); break; default: printf(" Ha ingresado un valor no vlido \n"); } printf("Ingrese 0 para terminar y cualquier nmero para continuar \n"); scanf("%d",&opcion); }

while(opcion); }
PREGUNTAS DE CERTAMENES DE AOS ANTERIORES 2008, REFERENTES AL MANEJO DE CICLOS EVALUACIONES LGICAS
AL
A continuacin se lista algunas preguntas que se encuentran en certamenes anteriores, ests preguntas estn con sus respuestas al final del apunte. PCR23.- Pregunta 1. Primer Certamen, Segundo Semestre 2007, 10 ptos. Dada la siguiente expresin: !( k>=j || k<=5) && (!(j=j-1 > k ) && ((i+1)==j/2))
Evale los valores de verdad (es decir, si el resultado es verdadero o falso) tanto al interior de cada parntesis, como en la expresin completa, con los valores de variable indicados en los casos a) y b) abajo expuestos. Las variables son de tipo entero (5 puntos cada caso). Casos: a) k=3, j=4, i=4 b) k=3 , j=7, i=3
PCR24. Pregunta 2. Primer Certamen, Segundo Semestre 2007, 25 ptos.

Dado los siguientes algoritmos, obtenga los valores de las variables que aparecen en la tabla en cada iteracin, para un valor inicial de N=6 (25 puntos el ejercicio completo).
ALGORITMO uno { int i,stop=1,cont,N printf Ingrese N scanf N for(i=1, cont=0;i<=N && stop !=0 ;i=i+1) { if (!(i/2)) printf 1 cont=cont+1 if(cont==3) stop=0 else printf 0 } }
Introduccin a la Programacin Departamento de Sistemas de Informacin Universidad del Bo-Bo PCR25. Pregunta 2. Primer Certamen, Segundo Semestre 2006, 25 ptos
Dado los siguientes algoritmos, obtenga los valores de las variables que aparecen en la tabla en cada iteracin, para un valor inicial de N=3
int i,j,suma1,suma2 Imprimir(Ingrese N) Leer(N) if(N>0) { suma1=0 for(i=1; i<=N ;i=i+1) { suma2=0 j=1 while (j<=i) { suma2=suma2+j j=j+1 } suma1=suma1+i+suma2 } Imprimir(suma1) } else { Imprimir(Error) } }
N 3
suma1
suma2
A continuacin se lista algunas preguntas que se encuentran en certamenes anteriores, ests preguntas estn propuestas, por lo que el alumno las debe de tratar de resolver. PCP 1.- Pregunta 3. Primer Certamen, Segundo Semestre 2006, 35 ptos
Analice el siguiente algoritmo, haga el seguimiento por lo menos para N=4 en la tabla indicando que es lo que imprime, y explique qu es lo que realiza para un valor N dado . int i, pot, exp for(i=1;i<=N;i=i+1) { pot=1 for(exp=1; exp<=i;exp=exp+1) { pot=pot*i } if(i%2!=0) printf i, exp-1, pot*(-1) else printf i, exp-1, pot }
pot
exp
Imprime:
Introduccin a la Programacin Departamento de Sistemas de Informacin Universidad del Bo-Bo PCP 2.a)
int i,j,suma=0,stop=1,N printf Ingrese N scanf N for(i=1;i<=N && stop !=0 ;i=i+1) { for(j=1;j<=i && stop !=0 ; j=j*2) if(j==(N/2)) stop=0 else suma=suma+i+j } print El resultado es suma
Dado los siguientes algoritmos, obtenga los variables que aparecen en la tabla en cada iteracin.
valores
de
las
N 4
stop
suma
b)
int i,j,k,N printf Ingrese N scanf N for(i=1;i<=N; i=i+1) for(j=1; j<= 2*N ;j=j+1) for(k=j;k>=0 ;k=k-1) if( k> j/2) printf 0 else printf 1 N i j k printf
PCP 3.- Pregunta 3. Test 1, Primer Semestre 2006, 30 ptos

Considere la sumatoria: (1+1)+(2+(1+2))+(3+(1+2+3))+(N+(1+2+N)) Cree un algoritmo para obtener dicho clculo, tanto en diagrama de flujo como en seudo-cdigo
Introduccin a la Programacin Departamento de Sistemas de Informacin Universidad del Bo-Bo PCP 4 .- Pregunta 1.2. Test 2, Primer Semestre 2006, 10 ptos Considere el siguiente programa en lenguaje C:
#include <stdio.h> int main(){ int n,i; printf("Ingrese un nmero\n"); scanf("%d",&n); i=0; while (n>1){ if ((n%2)==0) n=n/2; else n=n*3+1; i++; } printf("\n\n%d",i); return (0); }
Si el usuario ingresa el valor 10, el resultado mostrado en pantalla por el programa es: a) 1 b) 5 c) 10 d) 11 e) Ninguno de los anteriores
PCP 5.- Pregunta 2. Examen, Primer Semestre 2006, 20 ptos

Considerando el siguiente trozo de cdigo: i = 0; while (i < 29) { if (i == 29) printf(%d, i); i++; } Qu valor se imprime en la salida estndar (pantalla)? Justifique su respuesta.
PARTE 3: DEFINICIN DE UNA FUNCIN

Uno de los conceptos actualmente utilizados en el mundo del software, es la de Modularidad. Se ha dicho que la Modularidad, es el atributo individual del software que permite a un programa ser intelectualmente manejable. El software monoltico (es decir, un programa compuesto de un nico mdulo) no puede ser fcilmente abarcado por un lector. El nmero de caminos de control, la expansin de referencias, el nmero de variables y la complejidad global podran hacer imposibles su correcta compresin. Para ilustrar este punto, consideremos la siguiente disquisicin, basada en observaciones sobre la resolucin humana de problemas. Sea C(x) una definicin de la complejidad de un problema x y E(x) una funcin que define el esfuerzo (en tiempo) requerido para resolver un problema x. Para dos problemas, p1 y p2, si C(p1) > C(p2) se deduce que E(p1) > E(p2) 1.b 1.a
Para un caso general, este resultado es intuitivamente obvio. Se tarda ms tiempo en resolver un problema difcil. Se ha encontrado otra propiedad interesante, a partir de la experimentacin sobre la resolucin humana de problemas. Se trata de lo siguiente: C(p1 + p2) > C(p1) + C(p2) 1.c
La ecuacin 1.c indica que la complejidad de un problema compuesto por p1 y p2 es mayor que la complejidad total cuando se considera cada problema por separado. Considerando la desigualdad 1.c y la condicin implicada por las desigualdades 1.a y 1.b, se deduce que: E(p1+p2) > E(p1) + E(p2) 1.d
Esto nos lleva a una conclusin del tipo "divide y vencers". Por consiguiente deberemos considerar las funciones como "CAJAS NEGRAS", las cuales se encargaran de ejecutar una tarea especfica. Por lo tanto deberemos concentrarnos en el "Diseo Global de programa" en lugar de los detalles. La estructura de una funcin es como sigue: tipo_de_funcion nombre_de_la_funcion (argumentos) { Cuerpo de la Funcin return(variable valor); /* opcional solo cuando la funcin es de tipo void*/ }

Donde el tipo_de_funcion corresponde al tipo de datos que retorna devuelve dicha funcin, la cual puede ser del tipo entero ( int ) , flotante (float), carcter (char ) etc, adems es importante aclarar que aquellas funciones que no son definidas, por defecto son de tipo entero. argumentos: corresponde a valores recibidos por la funcin, los cuales tambin se deben definir de un tipo determinado, como si se tratase de una definicin de variable comn y corriente, cabe destacar adems que no necesariamente una funcin debe recibir un valor, si no que esta puede estar vaca. La estructura de los argumentos pueden ser: nombre_de_la_funcion (tipo_dato arg1,tipo_dato arg2,...,tipo_dato argN) tambin: nombre_de_la_funcion(arg1, arg2,..., argN) tipo_dato arg1,tipo_dato arg2,...,tipo_dato argN; { Cuerpo de la Funcin return(variable valor); } Cuerpo de la funcin: Corresponde al cdigo fuente que se encargar de realizar el proceso, aqu se debern declarar variables si fuese necesario, dichas variables son denominadas variables locales porque pertenecen a esa funcin y slo existen cuando el compilador toma dicha funcin, dejando de existir cuando el compilador termina de ejecutar dichas lneas de cdigo. Existen las variables globales, definidas en el programa principal, antes del main(), las cuales pueden ser utilizadas en cualquier parte del programa, incluyendo las funciones. return(variable valor): Corresponde al valor que retornar dicha funcin donde halla sido llamada, es importante destacar que una variable valor nico. Ms adelante veremos como retornar variables que tengan asociados ms de un valor, por lo que por el momento slo nos quedaremos con la proposicin inicial. Algunas veces no necesitaremos que las funciones nos retornen un valor, por lo que podremos omitir esta sentencia. A continuacin veremos algunos ejemplos de cada caso:
Ejemplo 3.1 Crear un programa utilizando funciones donde se sumen dos nmeros. En este programa existen variables globales (x e y) y variables locales (result en el cuerpo del programa principal; y las variables a y b en la funcin suma. Las variables locales slo tienen existencia durante la ejecucin de la respectiva funcin. Pueden existir variables locales con el mismo nombre en distintas funciones las cuales estarn haciendo referencia a posiciones distintas de memoria. Entrada: x,y Salida: x+y Restricciones: No tiene #include<stdio.h> int suma(int a,int b); // Todas las funciones se declaran antes que el main(), para que // puedan ser reconocidas por el compilador y utilizadas en cualquier // parte del programa int x,y; main() { int result; printf("Ingrese el primer valor \n"); scanf("%d",&x); printf("Ingrese el segundo valor \n"); scanf("%d",&y); result=suma(x,y); //se ingresan las variables adecuadas como parmetros y el //valor devuelto por la funcin es asignada a la variable result. printf("El resultado es : %d \n",result); } int suma(int a,int b) { return(a+b); } Ejemplo 3.2: Una forma distinta para el problema anterior est dado por el siguiente programa. Note que en la funcin suma, las variables a,b no han sido declaradas porque son argumentos (declaracin implcita por los argumentos), slo se trabajan con ellos. Entrada: a,b Salida: a+b Restricciones: No tiene #include<stdio.h> int suma(int a,int b); main() { int a,b,result; printf("Ingrese el primer valor \n"); scanf("%d",&a); printf("Ingrese el segundo valor \n"); scanf("%d",&b); result=suma(a,b);

printf("El resultado es : %d \n",result); } int suma(int a,int b) { int result; result=a+b; return(result); } Ejemplo 3.3: En este ejemplo, la funcin imprimir_valores no retorna ninguna valor, por lo que es denominada de tipo void. Entrada: a,b Salida: a+b Restricciones: No tiene #include<stdio.h> void imprimir_valores(int suma); main() { int a,b,result; printf("Ingrese el primer valor \n"); scanf("%d",&a); printf("Ingrese el segundo valor \n"); scanf("%d",&b); result=a+b imprimir_valores(result); // En este caso no se asigna a ninguna variable puesto que no retorna un valor. } void imprimir_valores(int suma) { printf("El resultado de la suma es %d\n",suma); } Ejemplo 3.4: Crear una funcin que entregue el nmero mayor de dos nmeros. Entrada: valor1,valor2 Salida: Si valor1 es >valor 2 imprime: valor1 Sino imprime valor2 Restricciones: No tiene #include<stdio.h> int mayor(int a,int b); main() { int valor1,valor2; printf("Ingrese un nmero \n"); scanf("%d",&valor1); printf("Ingrese un segundo valor \n"); scanf("%d",&valor2); printf("El nmero mayor es %d \n",mayor(valor1,valor2)); }

int mayor(int a,int b) { if(a>b) return(a); else return(b); }
Ejemplo 3.5: Otra forma para el mismo problema Entrada: valor1,valor2 Salida: Si valor1 es >valor 2 imprime: valor1 Sino imprime valor2 Restricciones: No tiene #include<stdio.h> void mayor(int a,int b); main() { int valor1,valor2; printf("Ingrese un nmero \n"); scanf("%d",&valor1); printf("Ingrese un segundo valor \n"); scanf("%d",&valor2); mayor(valor1,valor2); } void mayor(int a,int b) { if(a>b) printf("El nmero mayor es %d \n",a); else printf("El nmero mayor es %d \n",b); } Ejemplo 3.6: Crear un programa que calcule la suma, resta, multiplicacin o divisin segn seleccin del usuario, utilizando funciones. Entrada: a,b,opcion Salida: a+b, o a-b, o a*b, o a/b Restricciones: Si la opcin es divisin b debe de ser distinto de 0 #include<stdio.h> float suma(float a,float b); float resta(float a,float b); float mutltiplicacion(float a,float b); float division(float a,float b); main() { int bandera=1,opcion; float a,b;

printf("Ingrese a \n"); scanf("%f",&a); printf("Ingrese b \n"); scanf("%f",&b); printf("Ingrese 1 para sumar o,2 resta, 3 mutiplicacin,4 division \n"); scanf("%d",&opcion); if(opcion==3 && b==0.0) opcion=5; switch(opcion) { case 1 : c=suma(a,b); break; case 2: c=resta(a,b); break; case 3: c=multiplicacion(a,b); break; case 4: c=division(a,b); break; case 5: bandera=-1; break; default: bandera=0; } if(bandera==1) printf(" El resultado es : %d \n",c); else if(bandera==0) printf("Ingreso una opcin no vlida \n"); else printf("No se puede calcular \n"); }
float suma(float a,float b) { return(a+b); } float resta(float a,float b) { return(a-b); } float mutltiplicacion(float a,float b) { return(a*b); } float division(float a,float b); { return(a/b); }
Ejemplo 3.7: Crear un programa que calcule ab , utilizando funciones. Entrada: a,b Salida: ab Restricciones: No tiene #include<stdio.h> float potencia(int base, int exp); main( ) { int a,b; float pot; printf("Ingrese el valor de la base \n"); scanf("%d",&a); printf("Ingrese el valor del exponente \n"); scanf("%d",&b); pot=potencia(a,b); printf("El resultado es: %f \n",pot); } float potencia(int base, int exp) { int i; float pot; if(exp>=0) for(i=1,pot=1.0 ; i<=exp ; i++) pot=pot*base; else{ for(i=1,pot=1.0 ; i<= (-1*exp) ; i++) pot=pot*base; pot=1/pot; } return(pot); } N Ejemplo 3.8: Crear un programa, slo definiendo las funciones que calcule: (ii/i!) i=1 Note que se utiliza (float)pot , el cual se conoce con el nombre de cast. Los cast se utilizan para cambiar el tipo de dato de una variable, en este caso especifico cambiamos la variable pot de tipo de entero por tipo flotante. Entrada: N Salida: sumatoria desde 1 hasta N de ii/i! Restricciones: N>0 #include<stdio.h> int potencia(int base, int exp); int factorial(int valor);

main( ) { int i,fact,pot,N; float suma=0; printf("Ingrese N \n"); scanf("%d",&N); if(N>0) { for(i=1;i <=N ; i++) { pot=potencia(i,i); fact=factorial(i); suma=suma+(((float)pot) / ((float)fact)); } printf("El resultado es : %f \n",suma); } else printf("Ha ingresado un valor no valido \n"); } Ejemplo 3.9: Crear un programa que calcule N i ( (i+j)i / (i+1)! ) Utilizando funciones. i=1 j=1 Entrada: N Salida: sumatoria desde 1 hasta N de (i+j)i / (i+1)! Restricciones: N>0 #include<stdio.h> float potencia(int a,int b); float factorial(int valor); main() { int i,j,N; float suma=0.0; printf("Ingrese N \n"); scanf("%d",&N); if(N>0) { for(i=1;i<=N ;i++) for(j=1;j<=i;j++) suma=suma+(potencia(i+j,i)/factorial(i+1)); printf("El resultado de la suma es %f \n"suma); } else printf("Ingreso un valor no vlido \n"); } float potencia(int a,int b) { int i,pot=1; if(b>=0) {

for(i=1;i<=b ; i++) pot=pot*a; pot=(float)pot; } else { for(i=1;i<=(b*-1) ; i++) pot=pot*a; pot=1/float(pot); } return(pot); } float factorial(int valor) { int fact=1,i; for(i=1;i<=valor;i++) fact=fact*i; fact=(float)fact; return(fact); }
PASAJE
DE PARMETROS O ARGUMENTOS
Los valores que se le entregan como entrada a las funciones se conocen como prametros. Por ello, al momento de utilizar o llamar una funcin, se indica el nombre de la funcin junto con los prametros reales (valores especficos). Tambin es importante acotar que algunas funciones no podran llevar argumentos, por lo que en ese caso los parntesis de la funcin pueden quedar vacias. Cuando un programa llama a una funcin la informacin importante se comunica a travs de la lista de parmetros y se establece una correspondencia automtica entre los parmetros reales y formales. Los parmetros reales son sustituidos por los parmetros formales y estos son los utilizados. #include <stdio.h> int f , a, b; /* variables globales*/ int suma(int c,int d); /*prototipo*/ main() { scanf(%d,&b); scanf(%d,&a); f = suma(a,b ); // a y b corresponden a los ... // parmetros reales } int suma(int c, int d) // c y d corresponden a // los parmetros formales { return (c+d); }
Existen mtodos diferentes para el paso de parmertos a funciones. Es preciso conocer la disponibilidad y la forma en que los lenguajes de programacin apoyan este concepto. Un mismo programa puede producir distintos resultados bajo diferentes formas de paso de parmetros.

Revisaremos dos tipos de paso de parmetro, por valor y por referencia. Por valor En este caso los parmetros se tratan como variables locales y los valores de los parmetros reales se copian en los correspondientes parmetros formales. Los cambios que se produzcan en los parmetros por efecto del subprograma (funcin) no afectan a los argumentos originales. Por referencia El mdulo que llama enva la direccin de memoria del parmetro real. Entonces una variable pasada como parmetro por referencia puede ser modificada directamente por el subprograma. En lenguaje C, cuando se realiza un paso de parmetro por referencia el argumento se precede del smbolo &.
Como ejemplo se pide comparar los siguientes cdigos: Por valor ... int a, b, c; a=5; b=6; c=20; sumar(a,b,c); printf( el valor de c es %d, c); ... } void sumar(int x, y, z) { z = x + y; } Por referencia ... int a, b, c; a=5; b=6; c=20; sumar(a,b,&c); printf( el valor de c es %d, c); ... } void sumar(int x,y,* z) { *z = x + y; }
PREGUNTAS DE CERTAMENES DE AOS ANTERIORES 2008, REFERENTES AL MANEJO DE FUNCIONES
AL
A continuacin se lista algunas preguntas que se encuentran en certamenes anteriores, ests preguntas estn con sus respuestas al final del apunte. PCR31.- Pregunta 4. Segundo Certamen, Primer Semestre 2006, 20 ptos.
Realice el seguimiento del siguiente programa. Indique en la tabla los valores que toma cada variable. #include <stdio.h> int n,j; int funcionX(int x); main() { for (j=4;j<=9;j++) { if (funcionX(j)==j) printf ("\n %d Si es !!",j); } } /* Funcion */ int funcionX(int x) { int i, suma; suma=0; i=1; while (i<x) { if ((x%i) = =0) suma=suma+i; i++; }; return(suma) } main() Monitor funcionX i sum
j 4
Pasaje de parmetros 5 puntos Impresin correcta 5 puntos Trazado funcin 10 puntos
PCR32.- Pregunta 3. Certamen Recuperativo, Segundo Semestre 2007, 20 ptos.

Crear una funcin en C, que calcule lo siguiente:
2!*3!*4!*...* (i + 1)!
i =1
1 * 3 * 5 * ... * (2i 1)
PCR33. Pregunta 2. Examen de Repeticin, Segundo Semestre 2007, 15 ptos.

Construir una funcin en C, dado N, que permita calcular lo siguiente:
1!2 2 + 3!4 4 + 5!6 6....

PCR34. Pregunta 1. Segundo Certamen, Segundo Semestre 2007, 25 ptos.
Construya una funcin en C que permita CALCULAR y RETORNAR el resultado de la siguiente serie numrica:
S =
1 * 3 * 5 * 7 * 9 * L * (2i 1) 4 * 8 *12 * L * 4i i =1
n
Introduccin a la Programacin Departamento de Sistemas de Informacin Universidad del Bo-Bo PCR35.- Pregunta 3. Segundo Certamen, Primer Semestre 2006, 25 ptos. Construya un programa que permita calcular la sumatoria de la siguiente funcin evaluada en el intervalo [a,b] de tipo entero, ingresado desde teclado. b F(X) i=a X3 5x Si x >5 X5 F(X) X2 + 3x X1 -(x2 + 10x) 25 Si 1 < x <= 5 Si x <= 1
PCR36.- Pregunta 3. Examen de Repeticin, Primer Semestre 2006, 35 ptos.

Construir un programa en C que permita evaluar la siguiente sumatoria
i i+2 (i + 1)! i =0
n
Este programa debe incorpora el uso de funciones creadas por Usted (no se permite el uso de funciones existentes en las libreras del C).
A continuacin se lista algunas preguntas que se encuentran en certamenes anteriores, ests preguntas las deben de resolver los alumnos. PCP37.- Pregunta 3. Segundo Test, Segundo Semestre 2007, 25 ptos.
Construir una funcin en C que permita DEVOLVER la suma de los primeros K trminos de la serie:
S = 2+
x x x x + + ... 3 4 5 6
El valor de x y de K debern ser entregados como argumentos a la funcin.
Introduccin a la Programacin Departamento de Sistemas de Informacin Universidad del Bo-Bo PCP38.- Pregunta 4. Segundo Test, Segundo Semestre 2007, 15 ptos.
Qu imprime en la salida estndar? DEBER JUSTIFICAR SU RESPUESTA #include <stdio.h> /* Prototipo de funciones */ int adivina(int, int); int main() { int a, b, resultado;
/* Almacena resultados de operaciones */
printf( "Valor 1 = "); scanf("%d", &a); printf( "Valor 2 = "); scanf("%d", &b); resultado = adivina(a,b); printf( "a = %d\n", a); printf( "Resultado = %d\n", resultado); return 0; } int adivina(int a, int b) { if (a < b) a = b; return a; }
PARTE 4: ARREGLOS UNIDIMENSIONALES

Un arreglo es un conjunto de datos del mismo tipo que se puede representar de la siguiente manera: 5 0 Datos 6 1 7 2 8 3 Indice 7 4 4 5 8 6 0 7
Dicho arreglo podra haber sido representado por una definicin de 8 variables de tipo char. Cabe destacar adems que los arreglos comienzan en el ndice 0. Para declarar un arreglo se sigue la siguiente sintaxis. Tipo_Dato Nombre _Variable[Cantidad_Elementos ];
Ejemplo 4.1: Declaracin y lectura de un arreglo

int a[10] //nombre del arreglo y dimensin) { a[4]=10; // en la posicin 5 del arreglo se almacena el valor 10 } Lectura del arreglo definido (llenado): for (i=0; i<10;i++) { printf(\n Ingrese elemento A[%d] = ,i); scanf(%d;&a[i]); } Supongamos lo siguiente : 5 4 3 2
Este arreglo se llama Ejemplo (int Ejemplo[4]); para hacer referencia al primer elemento, se debe escribir Ejemplo[0]; supongamos: c=Ejemplo[0]; entonces c , vale 5.
INICIALIZACIN
DE ARREGLOS
Para inicializar un arreglo se sigue la siguiente sintaxis: Tipo_Dato Nombre_Variable[ Cantidad_Elementos]={ valor1, ... , valorN }; int Ejemplo[4]={5, 4, 3, 2 }; Se inicializa el arreglo con los valores especificados entre { }
Ejemplo 4.2: Ingresar 10 elementos utilizando arreglos y mostrar el mayor. Entrada: 10 enteros Salida: El mayor de los 10 enteros Restricciones: ninguna #include<stdio.h> main() { int arr[10], i, mayor; for(i=0;i<10;i++) { printf("Ingrese el %d valor \n",i+1); scanf("%d",&arr[i]); } for(i=1,mayor=arr[0];i<10;i++) if(mayor>arr[i]) mayor=arr[i]; else continue; printf("El nmero mayor es %d \n",mayor); }
Ejemplo 4.3: Ver que realiza el siguiente programa

#include <stdio.h> int i,s,a[5],m; float p; main() { for ( i=0; i<5 ; i++) { printf("\n Ingrese elemento A[%d] = ",i); scanf("%d",&a[i]); } s=0; m=1; for ( i=0; i<5 ; i++) { s = s + a[i]; m = m * a[i]; } p=m/s; printf("suma <%d> , multiplicacion <%d> resultado?? es <%f>",s,m,p); getchar(); getchar(); }

Ejemplo 4.4: Qu realiza el siguiente programa? #include <stdio.h> int i,a[5],b[5],m,a1,b1; main() { printf("\n Ingrese los elementos al primer vector "); for ( i=0; i<5 ; i++) { printf("\n Ingrese elemento A[%d] = ",i+1); scanf("%d",&a[i]); } printf("\n ingrese los elementos al segundo vector "); for ( i=0; i<5 ; i++) { printf("\n Ingrese elemento B[%d] = ",i+1); scanf("%d",&b[i]); } m=0; a1=a[0]; b1=b[0]; for ( i=0; i<5 ; i++) { if (a[i] > a1) a1=a[i]; if (b[i] < b1) b1=b[i]; m=m + a[i] * b[i]; } printf("\n El valor de a1 es %d",a1); printf("\n El valor de b1 es %d",b1); printf("\n El valor de m es %d",m); getchar(); }
CADENAS
STRINGS
Los strings o cadenas son arreglos unidimensionales de tipo char. Por convencin, un string en C se termina con el carcter nulo \0. Por ejemplo, si tenemos char a[5], el elemento a[4] es el \0. Las constantes de strings se escriben entre comillas; por ejemplo, ``abc'' es un arreglo de caracteres de tamao 4, donde el ltimo elemento es el carcter nulo \0.
Inicializacion de String: char arreglo[5]={h,o,l,a,\0};

Ejemplo 4.5: Crear un programa donde se ingrese el nombre y la edad, y posteriormente se muestre en pantalla. Entrada: Una cadena de caracteres (nombre), y un entero (edad) Salida: El nombre y la edad ingresados desde teclado Restricciones: ninguna #include<stdio.h> main()

{ char nombre[20]; int edad; printf("Ingrese su nombre \n"); gets(nombre); printf(" Ingrese su edad \n"); scanf("%d",&edad); printf("Hola %s ,tu edad es de %d, ves que tengo buena memoria \n",nombre,edad); } Aqu se ha utilizado la funcin gets, la cual permite capturar toda la cadena desde teclado colocando el /0 al final de la cadena. Esto permite manejar de manera ms simple el ingreso de cadenas a diferencia del scanf. Note adems que basta con colocar el nombre de la cadena entre los parntesis para capturar la cadena. Ejemplo 4.6: Crear un programa donde ingreses un nombre y muestre la longitud del nombre ingresado. Entrada: Una cadena de caracteres (nombre) Salida: El largo del nombre (Note que tambin se cuentan los ) Restricciones: ninguna #include<stdio.h> main() { char nombre[20]; int i,largo; printf("Ingrese su nombre \n"); gets(nombre); for(i=0,largo=0; nombre[i]!='\0';i++) largo++; printf("El largo de su nombre es %d\n",largo); } Ejemplo 4.7: Crear un programa que cuente cuantas vocales posee un string. Entrada: Una cadena de caracteres Salida: la cantidad de vocales que hay en la cadena ingresada Restricciones: ninguna #include<stdio.h> main() { char nombre[20]; int i,cuentaVocales; printf("Ingrese un string \n"); gets(nombre); for(i=0, cuentaVocales =0;nombre[i]!='\0' ;i++) if(nombre[i]=='a' || nombre[i]=='A') cuentaVocales ++; else if(nombre[i]=='e' || nombre[i]==E') cuentaVocales ++;

else if(nombre[i]=='i' || nombre[i]==I') cuentaVocales ++; else if(nombre[i]=='o' || nombre[i]==O') cuentaVocales ++; else if(nombre[i]=='u' || nombre[i]==U') cuentaVocales ++; else continue; printf("La cantidad de vocales en el arreglo es %d\n", cuentaVocales); } Ejemplo 4.8: Cree un programa que invierta un nombre. Entrada: Una cadena de caracteres (nombre) Salida: Una cadena de caracteres invertida (nombre invertido) Restricciones: ninguna #include<stdio.h> main() { char nombre[20]; char aux[20]; int i,j,largo; printf("Ingrese su nombre \n"); gets(nombre); for(i=0,largo=0; nombre[i]!='\0';i++) largo++; for(i=largo-1,j=0; i>=0 ; i--,j++) aux[j]=nombre[largo]; aux[j]=\0; printf("El nombre invertido es %s\n",aux); }
ARREGLOS
BIDIMENSIONALES
Un arreglo multidimensional, es un arreglo de arreglos. Una matriz es un arreglo bidimensional. Declaracin de una matriz: int arreglo[filas][columnas]; int a[5][5],m[10][4],i,j,f,c // nombre del arreglo y dimensin Ejemplo: int arreglo[5][3]; Su representacin es: columna 1 0 Fila 1 Fila 2 Fila 3 Fila 4 Fila 5 0 1 2 3 4 columna 2 1 columna 3 2

Lectura de una Matriz (llenado): for (i=0; i<5;i++) { for (j=0; j < 5 ; j=j+1) { printf(\n Ingrese elemento A[%d][%d] = ,i,j); scanf(%d;&a[i][j]); } } Cada elemento se referencia a travs del nombre y su ubicacin en el conjunto, por ejemplo: { a[4][2]=10; // Se almacena en la fila 5, columna 3 el valor 10 m[0][5]=0; // Se almacena en la fila uno, columna 6 el valor 0 if (a[i][j] == a[j][i] ) // se consulta si el valor ubicado en la fila i-1 y columna j-1 es igual al elemento // almacenado en la fila j-1 y columna i-1 } Consideraciones importantes asociadas al uso de matrices: El procesamiento de todos los elementos requiere como mnimo dos ciclos iterativos Dentro de los ciclos se deben realizar las operaciones especificas que se solicitan Una matriz cuadrada es aquella en el numero de filas es igual al numero de columnas entre las aplicaciones ms importantes de las matrices est la posibilidad de resolver sistemas de ecuaciones con n variables.

Las matrices cuadradas tienen algunas caracteristicas importantes asociadas a la ubicacin de sus elementos en el conjunto. Se puede hablar de diagonal principal, diagonal secundaria, triangular superior, triangular inferior, por mencionar algunas.
Diagonal Principal
f=c
Diagonal Secundaria
f+c = Dim - 1
afc
Triangular Superior f<c
6x6 Triangular inferior f>c
Ejemplo 4.9: Crear un programa donde se introduzca 2 matrices de 4x4 y que entregue el resultado de la suma de ambas matrices: Entrada: Ingreso de valores para dos matrices de 4X4 Salida: Muestra el resultado de la suma de ambas matrices Restricciones: ninguna #include<stdio.h> main() { int matriz1[4][4], matriz2[4][4],fila,columna,matriz3[4][4]; printf(Ingrese los valores de la primera matriz \n); for(fila=0;fila<4;fila++) { for(columna=0;columna<4;columna++) { printf(Ingrese el valor fila %d , columna %d \n,fila+1,columna+1); scanf(%d,&matriz1[fila][columna]); } } printf(Ingrese los valores de la segunda matriz \n); for(fila=0;fila<4;fila++) { for(columna=0;columna<4;columna++) {

printf(Ingrese el valor fila %d , columna %d \n,fila+1,columna+1); scanf(%d,&matriz2[fila][columna]); } } for(fila=0;fila<4;fila++) // Se suman ambas matrices { for(columna=0;columna<4;columna++) matriz3[fila][columna]=matriz1[fila][columna]+matriz2[fila][columna]; } for(fila=0;fila<4;fila++) // Se muestra el resultado { for(columna=0;columna<4;columna++) printf( el valor de la suma del elemento en la fila %d columna %d es: %d \n, fila+1,columna+1,matriz3[fila][columna]); } }
EJERCICIOS PARTE 4: ARREGLOS

1.- Crear una funcin que calcule el largo de una cadena. 2.- Crear una funcin que cuente la coincidencia de 1 carcter dentro de un arreglo. 3.- Crear una funcin que cuente cuntas vocales se encuentran dentro de un arreglo. 4.- Crear una funcin que concatene dos cadenas. 5.- Crear una funcin que invierta una cadena. 6.- Crear una funcin que copie de una cadena a otra. 7.- Crear una funcin que copie de una cadena a otra a partir del i-simo elemento. 8.- Crear una funcin que compare dos arreglos y si son iguales retorne 1, en caso contrario que retorne 0. 9.- Crear una funcin que verifique si una matriz es diagonal (10x10). 10.- Crear una funcin que calcule: A D G B E H C F I J K L = AJ DJ GJ BK EK HK CL FL IL
Las matrices son positivas. 11.- Crear una funcin que verifique si una matriz es positiva. 12.-Crear una funcin que realice el producto escalar de dos vectores 13.- Crear una funcin que verifique si una matriz es una matriz superior. 14.-Crear una funcin que verifique si una vector de (1x3), est contenido en una matriz de (3x3) de enteros.15.-Crear una funcin que sea capaz de intercambiar 2 filas dos columnas de una matriz de 4x4.16.- Crear una funcin que analice sintaticamente si un arreglo contiene los sigiuientes valores ASCII: 0-9 , ( , ) , + , - , * , / .

17.- Crear una funcin que analice semnticamente si se puede realizar una operacin matemtica con los siguientes caracteres : 0-9 , ( , ) , + , - , * , /
PREGUNTAS DE CERTAMENES DE AOS ANTERIORES AL 2008, REFERENTES AL MANEJO DE ARREGLOS, CADENAS Y MATRICES
A continuacin se lista algunas preguntas que se encuentran en certamenes anteriores, ests preguntas estn con sus respuestas al final del apunte. PCR41.- Pregunta 4. Segundo Certamen, Segundo Semestre 2007, 20 ptos.
Dado el siguiente programa en C, se pide que usted INDIQUE CLARAMENTE qu es lo que hace el programa. Suponga la cadena de entrada ahumada OBS. Deber justificar su respuesta con una tabla de seguimiento #include <stdio.h> char adivina_que_hago(char []); int main() { char frase[50]; printf("frase = "); gets(frase); printf("R : %c\n", adivina_que_hago(frase)); return 0; } char adivina_que_hago(char x[]) { int v[5]={0,0,0,0,0}, i, k, p, m; char a[] = {'a','e','i','o','u'}; i = 0; while (x[i] != '\0') { if (x[i] == 'a') k = 0; if (x[i] == 'e') k = 1; if (x[i] == 'i') k = 2; if (x[i] == 'o') k = 3; if (x[i] == 'u') k = 4; v[k]+=1; i++; } for(m=v[0], p=0, i=1; i < 5; i++) { if (v[i] > m) { m = v[i]; p = i; } } return a[p]; }
PCR42.- Pregunta 1. Examen de Repeticin, Primer Semestre 2007, 30 ptos.

Construir un programa que permita imprimir todos los elementos menores al elemento mayoritario. En caso de no existir un elemento mayoritario, imprimir todos los elementos. Se dice que un elemento es mayoritario si se encuentra repetido ms de la mitad de las veces del total de elementos del arreglo (mayor a n/2). Asuma que el vector V de dimensin n ya est ingresado. Ejemplos: V V 1 1 2 3 0 8 2 3 2 5 2 4 3 Se debe imprimir el 1 y el 0 Se debe imprimir: 1 3 8 3 5 4 3
PCR43.- Pregunta 1. Examen, Primer Semestre 2007, 35 ptos.

En la segunda guerra mundial, se crearon algoritmos de encriptacin para codificar mensajes con el objeto de que el enemigo no supiera que contenan dichos mensajes. Los profesores de introduccin a la programacin han creado su propio algoritmo, con el objeto de que informacin clasificada (como los certmenes) no caigan en manos indebidas. Sin embargo, necesitan que sus alumnos le ayuden con la programacin de dicho algoritmo. El algoritmo funciona de la siguiente manera: La matriz se llena con una palabra o frase secreta descartando las letras repetidas. Se rellenan los espacios de la tabla con las letras del alfabeto en orden. La frase secreta se ingresa a la matriz de izquierda a derecha y arriba hacia abajo. La frase secreta junto con la convencin sirve para llenar la matriz de 5x5 que constituyen la clave de encriptacin. Por ejemplo: Si la frase secreta es "INTRODUCCION A LA PROGRAMACION" La encriptacin se realiza de la siguiente forma: I D P N U G T C M R A O L Para cada letra del mensaje original se busca la letra y se cambia por el elemento contiguo (lado derecho del carcter, si es el carcter final de una fila el primero de la fila subsiguiente).Si la letra no est en la matriz, se deja el mismo carcter, se aplica lo mismo cuando se trata del ltimo elemento de la ltima fila. Ejemplo: Supongamos que queremos codificar CERTAMEN, entonces el texto encriptado sera: AEORLMET Para lograr esto se le pide que construya un programa que utilice funciones (creadas por ud.) que realice la encriptacin de una palabra ingresada por teclado.

Crear un programa utilizando funciones, el cual reciba un arreglo de n elementos de tipo entero, y un nmero entero. Posteriormente realiza una bsqueda sobre el arreglo para determinar si es que existen dos elementos del arreglo que sumados den el entero ingresado. Si existen estos valores, se deben de mostrar en pantalla, en caso contrario indicar que no existen elementos que sumados den el nmero. Ejemplo: 5 12 4 1 Si se ingresa 6 debe imprimir 5 y 1 Si se ingresa 7 se debe imprimir no existen elementos

Para el registro de notas finales de un curso se cuenta con el vector NOTAS de dimensin 40 de tipo entero y una matriz NOMBRE de 40x20 de tipo char ordenada alfabticamente (ninguna seccin debe exceder esta cantidad de estudiantes). En cada fila de la matriz NOMBRE se almacena el nombre y apellido de cada alumno. La nota ubicada en la posicin k del vector NOTAS corresponde a la nota final del alumno ubicado en la fila k de la matriz nombre. Se pide construir un programa en C que permita generar UN listado donde se impriman primero los nombres de los alumnos cuya nota final sea mayor o igual al promedio de todo el curso, con un encabezado que diga LISTADO DE ALUMNOS SOBRE EL PROMEDIO, y luego se impriman los nombres de los alumnos cuya nota final sea menor al promedio de todo el curso, con un encabezado que diga LISTADO DE ALUMNOS BAJO EL PROMEDIO.

Dado un vector de dimensin n de tipo entero, ledo desde teclado, construir un programa o funcin que permita determinar la existencia de un elemento mayoritario. En caso de existir se debe imprimir (o retornar en caso de funcin) dicho valor. Se dice que un elemento es mayoritario si se encuentra repetido ms de las mitad de las veces del total de elementos del arreglo (mayor a n/2). El arreglo no necesariamente esta ordenado.
PCR47.- Pregunta 3. Segundo Certamen, Segundo Semestre 2007, 30 ptos.

Dada una matriz cuadrada de dimensin 20 de tipo char, construir un programa que permita determinar si un vector de dimensin menor o igual a 20 est contenido en una fila o una columna de la matriz. Este vector puede encontrarse en la matriz en la misma secuencia o en sentido inverso. Tanto la matriz como el vector deben ser ledos desde teclado.

Dado un arreglo bidimensional Nx2 que contiene puntos en un espacio de dos dimensiones y un punto q como consulta (en el espacio de dos dimensiones), encontrar todos los puntos cercanos a q, tal que la distancia euclidiana entre ellos es menor o igual a una distancia r. Cree una funcin

que deje los puntos <=r en una matriz llamada R (mximo Nx2). Puede utilizar la funcin sqrt() de la librera math.h para calcular la raz. Dados dos vectores, v= (v1,v2,,vn) y w=(w1,w2,, wn), la distancia euclidiana queda definida como:
( w1 v1 ) 2 + ( w2 v 2 ) 2 + ... + ( wn v n ) 2
Dados los siguientes arreglos, cuenta_corriente (tamao Nx5) y depsitos (tamao Mx11) tal que M>=N, crear una funcin que muestre el estado de la cuenta para un mes en particular. La nomeclatura para el arreglo cuenta_conrriente es el siguiente: 1 4 7 2 5 8 3 6 9 A B C
Este arreglo no tiene elementos repetidos (no existen cdigos de cuentas repetidas, cada fila corresponde a una cuenta). La nomeclatura para el arreglo depsitos es la siguiente: 0 1 4 1 7 1 2 5 2 8 2 3 6 3 9 3 4 A B A C 5 1 1 2 2 6 0 1 1 0 7 1 2 1 0 8 2 0 0 1 9 0 0 0 0 10 0 0 0 0
La columna con ndice 0 al 4 corresponde al cdigo de la cuenta, mientras que la columna 5 corresponde al mes, y del ndice 6 al 10 corresponde a los valores (note que siempre son positivos). Crear una funcin que dado un cdigo busque en la matriz depsitos el total de depsitos. Por ejemplo, para 123-A, debera de mostrar 12.000. Puede utilizar la funcin llamada atoi() que transforma un arreglo a enteros. Tambin puede utilizar la funcin strcmp.
A continuacin se lista algunas preguntas que se encuentran en certamenes anteriores, ests preguntas las deben de resolver los alumnos.
PCP41.- Pregunta 1. Segundo Test, Segundo Semestre 2007, 30 ptos.

Dadas dos cadenas, una con una palabra a reemplazar (tamao K) y otra con una frase donde se encuentra la palabra a reemplazar (tamao N) donde N>K, crear una funcin que reemplace la palabra en el texto. El texto final puede quedar en una cadena llamada TextoFinal (de tamao M) donde M>=N+K. Por ejemplo: La cadena reemplazar es: adis despedida La cadena frase: El dio un adis a quienes ms quera

La cadena TextoFinal es: El dio un despedida a quienes ms quera Note que slo existe un espacio entre la palabra a buscar y el texto a reemplazar en la cadena reemplazar. Se pide crear una funcin que realice dicho reemplazo
PCP42.- Pregunta 2. Segundo Test, Segundo Semestre 2007, 30 ptos.

Dada la cadena Notas (vector de caracteres de Nx16), ingresar en la misma cadena (al final) el promedio de los alumnos, notar que el rut, slo ocupa 4 elementos, entre las notas y el rut existe un solo espacio y queda espacio final (3 espacios) para colocar el promedio. Utilice la funcin atoi, la cual transforma una cadena a enteros. Ejemplo: 1 2 3 1 2 3 1 2 3 0 0 0 5 6 4 0 0 9 0 0 1 6 6 0 0 0 0
Finalmente la cadena Notas debera de quedar: 1 2 3 1 2 3 1 2 3 0 0 0 5 6 4 0 0 9 0 0 1 6 6 0 0 0 0 0 0 0 5 6 7 5 0 3
PCP43.- Pregunta 2. Segundo Certamen, Segundo Semestre 2006, 25 ptos.

2- Dado el siguiente programa, obtenga los valores de las variables que aparecen en la tabla en cada iteracin, para un valor inicial de N=3 (15 puntos el ejercicio completo). 3- Cul es la expresin que resuelve este programa? (10 puntos)
#include<stdio.h> #include<conio.h> int funcion1(int array[],int elem, int N);
int main( ) { int i; int array[4]={0,1,1,1} //arreglos inicializado for(i=0;i<4;i++) if(funcion1(array,array[i],4)==1) printf(el elemento es %d,array[i]); else continue; printf(No existe elemento); } int funcion1(int array[],int elem, int N) { int i, cont; Pgina : 78 Claudio Gutirrez-Soto, Manuel Crisosto,

for(i=0,cont=0;i<N;i++) if(elem==array[i]) cont++; else continue; if(cont> N/2) return(1); else return(0); }
PCP44.- Pregunta 3.1. Segundo Certamen, Segundo Semestre 2006, 30 ptos.

Crear un programa que verifique si es que dos arreglos de enteros contienen los mismos elementos (arreglos de 7 elementos). Considere que los arreglos ya estn ingresados. Adems los elementos pueden estar desordenados y no existen elementos repetidos en el arreglo. Es decir se pueden encontrar en distintos posiciones en los arreglo. Por ejemplo, los siguientes arreglos 1 y 2 contienen los mismos elementos. Arreglo 1 2 3 7 6 Arreglo 2 1 2 3 4 5 5 4 6 1 7
PCP45.- Pregunta 3.1. Segundo Certamen, Segundo Semestre 2006, 30 ptos.

Escriba un programa en lenguaje C que verifique si una matriz de 10x10 (de tipo entero) es triangular superior. Se dice que una matriz es diagonal superior si todos los elementos sobre la diagonal principal tienen el valor 1, y todos los elementos restantes son 0. La siguiente figura representa una matriz diagonal superior de 5x5.. Al igual que en la pregunta anterior considere que los elementos del arreglo ya han sido ingresados. 0 0 0 0 0 1 0 0 0 0 1 1 0 0 0 1 1 1 0 0 1 1 1 1 0
Introduccin a la Programacin Departamento de Sistemas de Informacin Universidad del Bo-Bo PCP46.- Pregunta 1. Segundo Test, Primer Semestre 2006, 20 ptos.
Considere el siguiente programa en lenguaje C: #define N 5 #include<stdio.h> int main(){ int arr[N]={25,30,12,40,20}; int i,j,aux; for (i=0; i<=N-2; i++) for (j=i+1;j<=N-1; j++) if (arr[i]>arr[j]) { aux=arr[i]; arr[i]=arr[j]; arr[j]=aux; } for (i=0;i<N;i++) printf("pos %d = %d\n",i,arr[i]); return (0); } Al ejecutar este programa, lo que se imprime en pantalla es: a) b) c) d) pos 0 = 12 pos 0 = 12 pos 0 = 30 pos 0 = 40 pos 1 = 20 pos 1 = 20 pos 1 = 40 pos 1 = 30 pos 2 = 25 pos 2 = 25 pos 2 = 25 pos 2 = 25 pos 3 = 30 pos 3 = 40 pos 3 = 20 pos 3 = 20 pos 4 = 40 pos 4 = 30 pos 4 = 12 pos 4 = 12 e) Ninguna de las anteriores
PCP47.- Pregunta 2.2. Segundo Test, Primer Semestre 2006, 30 ptos.

Escriba un programa en lenguaje C que reciba dos palabras, y los intercale en un tercer String. Por ejemplo, si su programa recibe los String Hola y Que, el String que debe generar es HQoulea. En su programa, debe considerar un largo mximo de String de 100, pero cuando haga el intercalamiento, debe recorrer slo aquellas posiciones que contengan caracteres vlidos (en el caso del String Hola, debe recorrer slo los primeros 4 caracteres).
Introduccin a la Programacin Departamento de Sistemas de Informacin Universidad del Bo-Bo PCP48.- Pregunta 3. Examen, Primer Semestre 2006, 25 ptos.
Construir un programa en C que permita llenar una matriz de 5X5 y un vector de capacidad 5, con nmeros enteros ledos desde teclado, luego deber imprimir en la salida cuntas veces se encuentra el vector en la matriz por fila y por columna, en el mismo orden. Por ejemplo, sea la matriz: 1 2 3 1 2 1 1 3 1 2 1 2 2 1 1 1 1 1 1 1 2 1 1 1 1 1 1 1 1 1
Y el vector: Su programa debera escribir 3 veces
PCP49.- Pregunta 4. Examen, Primer Semestre 2006, 35 ptos.

Todo libro editado tiene un nmero identificador que consta de diez cifras. A dicho nmero se le denomina ISBN (del ingls International Standard Book Number) y suele aparecer en las primeras pginas junto a otros detalles de la edicin. El ISBN se divide en dos partes. La primera, formada por las nueve primeras cifras, identifica el idioma del libro, la editorial y el libro propiamente dicho. Estas primeras nueve cifras son siempre dgitos, es decir, valores entre 0 y 9. La segunda parte es el dgito de control, que en realidad puede ser un dgito o la letra X. Si se llama Xi al dgito que aparece en la posicin i-sima, la dcima cifra viene dada por la siguiente ecuacin:
9 X 10 = i * X i mod 11 i =1
Al dividir por 11 se obtiene un resto entre 0 y 10; si es 10 se pone como dgito de control la letra X, de lo contrario el dgito de control viene dado por el valor obtenido de la ecuacin. Se pide construir un programa en C que permita leer un nmero ISBN y permita determinar si es un nmero ISBN correcto o no. NOTA. Para decidir si un nmero ISBN es correcto o no se compara el dgito de control ingresado con el que se obtiene con la ecuacin anterior. - Asuma que en la primera parte del ISBN (los primeros nueve caracteres), siempre son caracteres numricos. - Por ejemplo: 2 3 7 6 5 4 1 2 3 - X
Introduccin a la Programacin Departamento de Sistemas de Informacin Universidad del Bo-Bo PCP49.1.- Pregunta 2. Examen Repeticin, Primer Semestre 2007, 35 ptos.
Construya un programa en C que determine si una matriz de n x n ingresada por teclado cumple con la siguiente caracterstica: la suma de cada elemento de la fila (excepto el ltimo) es igual al ltimo elemento de la fila; la suma de cada elemento de la columna (excepto el ltimo) es igual al ltimo elemento de la columna. Adems el ltimo elemento de la matriz corresponde al menor valor entre la suma de la ltima columna y la suma de la ltima fila. Ejemplo: 2 11 3 4 20 M[5][5] 1 2 5 20 4 4 0 0 3 1 2 18 6 2 3 144 14 9 10 53
Su programa debe determinar si al ingresar por teclado cualquier matriz de n x n cumple con estas caractersticas.
PARTE 5: ESTRUCTURAS
Las estructuras son un conjunto de variables que se referencian bajo un mismo nombre, proporcionando un medio conveniente para mantener reunida la informacin relacionada. Las variables "campos" que abarca la estructura se llaman elementos de la estructura. En general cada elemento de la estructura est relacionada logicamente con los otros. Ejemplo 5.1: Definicin de una estructura para almacenar datos bsicos de una persona struct usuario{ char nombre[30]; char calle[40]; char cuidad[20]; char region[3]; char fono[7]; int edad; }; La palabra clave struct, le indica al compilador que est siendo declarada una estructura. Obsrvese que la definicin termina con un ; . Esto es debido a que la definicin de una estructura es una sentencia. Note que los campos dentro de una estructura no requieren ser del mismo tipo de dato. El nmero de estructuras y el nmero de campos depender del problema a resolver, Hasta este punto no se han declarado variables, slo se han definido las formas de los datos.
DECLARACIN
Sintaxis:
DE
VARIABLES
DE TIPO ESTRUCTURA
struct nombre_estructura var1,var2,.... ,varN; o struct nombre_estructura{ Elementos de estructura }var1,var2,....,varN; Ejemplo 5.2: Definicin de variables struct usuario user1, user2; Aqu hemos definidos 2 variables de tipo estructura llamadas user1 y user2. Otra forma de poder haber hecho esto seria: struct usuario{ char nombre[30]; char calle[40]; char cuidad[20]; char region[3]; char fono[7]; int edad; } user1,user2;
REFERENCIA
A LOS ELEMENTOS DE UNA ESTRUCTURA

.
Para hacer referencia a los elementos de una estructura se utiliza el operador punto . Sintaxis: var_tipo_struct.elemento
El nombre de la variable estructura va seguido del punto y del nombre del elemento, referenciando ese elemento individual de la estructura. Ejemplo 5.3: printf("Ingrese el nombre para el primer usuario \n"); gets(user1.nombre); printf("Ingrese la edad del primer usuario \n"); scanf("%d",&user1.edad);
ARREGLOS
DE ESTRUCTURAS
Supongamos nuestra estructura: struct usuario y que deseamos declarar N usuarios, se sucitaria lo siguiente: struct usuario{ char nombre[30]; char calle[40]; char cuidad[20]; char region[3]; char fono[7]; int edad; } user1,user2,..., userN; Lo cual para acceder a cada variable se traduce en algo realmente complejo; Para resolver esta complejidad podemos utilizar un arreglo. struct usuario{ char nombre[30]; char calle[40]; char cuidad[20]; char region[3]; char fono[7]; int edad; }user[N]; Por lo tanto se puede definir un arreglo de estructuras de la forma anterior o de la siguiente forma. struct usuario user[N]; lo cual es equivalente (a esta forma de almacenamiento en memoria principal se le denomina tabla). Para poder acceder a algun elemento del arreglo, se indica el nombre del arreglo, el ndice del arreglo y el elemento de la estructura. Por ejemplo: for(i=0;i<N ;i++) { printf("Ingrese el nombre para user[%d] \n",i); gets(user[i].nombre); }
ESTRUCTURAS
EN LAS FUNCIONES
Fuciones de tipo estructura Son las funciones que devuelven datos de tipo estructura. Sintaxis: struct nombre_estructura nombre_funcion(parametros) { } Ejemplo 5.4: En este ejemplo se crea una estructura que alamcena los elementos de los nmero complejos, osea el valor real y el imaginario. struct complejos{ float real; float imaginario; }; typedef struct complejos COMPLEX; COMPLEX asignar(float Real , float Imag) { COMPLEX a; a.real=Real; a.imaginario=Imag; return(a); }
ESTRUCTURAS
COMO PARMETROS DE UNA FUNCIN
Sintaxis: tipo_dato nombre_funcion(struct nombre_estructura) { /* Cuerpo de la funcion */ } COMPLEX suma(COMPLEX a , COMPLEX b) { COMPLEX z; z.real=a.real+b.real; a.imaginario=a.imaginario+b.imaginario return(z); }
EJERCICIOS
PARTE
5: ESTRUCTURAS
1.- Crear una funcin que maneje los complejos y una funcin que asigne valores a las variables reales e imaginarias. 2.- Crear una funcin que realice la suma de complejos y retorne el resultado. 3.-Crear una funcin que realice la multiplicacin complejos y retorne el resultado. 4.- Definido lo siguiente. struct Facultad FAC[15]; trabajo TRAB[15]; calidad CAL[15]; Personal PER[300]; Adems suponga que dichas estructuras ya poseen informacin. Crear una funcin que muestre a las personas que trabajan en la facultad de ingeniera. 5.- Crear una funcin que cuente la cantidad de personas de una determinada facultad. 6.- Crear una funcin que muestre a las personas de acuerdo a un determinado trabajo y a una determinada facultad. 7.-Transformar las siguientes tablas a estructuras. FACULTADES CodCarreraF FI FMF FA FC FM Descripcion Facultad de Ingeniera Facultad de Mat. y Fisica Facultad de Administracin Facultad de Ciencias Facultad de Medicina TRABAJO CodTrabajo Decano Encargado DocenteC DocenteA Director Secretaria Auxiliar Descripcin Decano Encargado de un bien Docente de Ctedra Docente Ayudante Director de Depto. Secretaria Auxiliar
PERSONAL CodCarreraF FI FI FI FMF ... Rut 1111-1 1112-1 1113-1 1114-1 ... Nombre Juan Prez Daniel Molina Marcelo Cceres Ivan Oyarzo ... CALIDAD CodCalidad Directivo Docente Secretario Auxiliar Descripcin Director de Departamento Escuela Profesor Secretaria Auxiliar CodTrabajo DocenteC DocenteC Director Auxiliar ... CodCalidad Docente Docente Directivo Auxiliar ... Sueldo 48 45 56 28 ...

8.- Dadas las siguientes estructuras struct Datos_Personales{ char nombre[20]; char rut[12]; int telefono; char direccion[30]; }DATOS[30]; struct Alumnos{ char rut2[12]; char ramo[20]; float Notas[3]; float promedio; }ALUMN[300]; 8.1) Crear una funcin que ingrese las notas para un ramo determinado. 8.2) Crear una funcin que calcule el promedio para un determinado ramo 8.3) Crear una funcin que muestre a los alumnos que deben dar examen en un determinado ramo. 9) Dadas las siguientes estructuras. struct Curso{ char CodCurso[3]; char NombreCurso[20]; }Class[10]; / cursos del colegio/ struct Ramos{ char CodRamo[5]; char NombreRamo[30]; char Cod_curso[20]; }Ramos_Curso[50]; /*5 ramos por curso*/ struct Notas{ char Rut[12]; float N1; float N2; float N3; float promedio; char Cod_Ramo[5]; char Cod_Curso[3]; }Notas_Ramo_Curso[500]; struc DatosPersonales{ char rut[12];

char nombre[20]; char Direccion[30]; int telefono; char cod_curso[3]; }ALUMNOS[100]; /* Alumnos del colegio*/ 9.1) 9.2) 9.3) 9.4) 9.5) 9.6) 9.7) Crear una funcin que ingrese los datos personales del alumno Crear una funcin que muestre a los alumnos( Nombre) de un determinado curso. Crear una funcin que muestre los ramos de un determinado curso Crear una funcin que permita ingresar las notas de un determinado curso y ramo. Crear una funcin que permita modificar una nota de un determinado alumno de un curso y ramo dados. Crear una funcin que calcule los promedio de un determinado ramo y curso Crear una funcin que muestre a los alumnos con un promedio determinado de un ramo y curso dado.
PARTE 6: PUNTEROS
Un puntero es una variable que hace referencia a una direccin de memoria Sintaxis: Tipo_Dato *nombre_variable_puntero; Ejemplo: int *p; Asignacin de Direccin nombre_puntero=&variable; El carcter & delante de una variable indica que lo se est accediendo es a la direccin de memoria de dicha variable. Ejemplo: int *p; p=0; /* p posee la direccin NULL 0*/ p=NULL; /* p posee la direccin NULL 0*/ p=&i; /*p apunta hacia i conteniendo la direccin de i */ p=(int )1501; /*direccion absoluta de memoria */ " Si p es un puntero, entonces *p es el valor de la variable a la que apunta ." Ejemplo 5.1: double x,y,*p; p=&x; y=*p; Lo anterior es equivalente a : y=*&x; y=x; Inicializacin Sintaxis: tipo_dato *nombre_puntero=&variable; Ejemplo: int i=7,*p=&i;

Construcciones a las que no se debe apuntar. *No apuntar a constantes. &3 /* ilicito*/ *No apuntar a arreglos, el nombre de un arreglo es una constante int a[77]; &a; *No apuntar a expresiones ordinarias &(k+99) *No apuntar a variables de tipo register. register v; &v; *Si a es un arreglo, expresiones como: &a[0] y a[i+j+3] adquieren sentido. 2.int i=3, j=5, k,*p=&i, q=&5,r; double x=11.5; Expresin equivalente P==(&i) *(*(&p)) R=(&r) ((3*(-(*p))))/(*q))+7 //ilicito (*(r=&k))=((*p)*(*q)) Valor 1 3 //ilicito 6 //ilicito 15
Expresin P==&i **&p R=&x 3*-*p/*q+7 3*-*p/*q+7 (r=&k)=*p**q Llamada por valor Mx(a,b) Int a,b; { return((a>b)?a:b); } Llamado por referencia Mx(a,b,m_ptr) Int a, b,*m_ptr; { *m_ptr=(a>b)?a:b; }
3- Relacin entre punteros y arreglos.

Un puntero es una variable cuyos valores son direcciones. El nombre de un arreglo es una direccin o puntero fijo. Cuando se declara un arreglo, el compilador debe asignar una direccin base y la cantidad de almacenamiento suficiente como para alojar a todos los elementos del arreglo #define TAM 100 int a[TAM], *p; y el sistema hece que los bytes numerados 300, 304, 309,......696 sean las direcciones de a[0], a[1], a[2],...,a[99]. p=a; = p=&a[0];
Aritmetica de punteros
La aritmtica de puntero proporciona una opcin para la indizacin de arreglos, las proposiciones p=a+1; Sumar un arreglo: suma=0; for(p=a; p<&a[TAM];++p) suma+=*p; o suma=0; for(i=0;i<TAM;++i) suma+=*(a+i); Debido a que a es un puntero constante, las expresiones como: a=p; ++a; a+=2; = p=&a[1];
Son ilcitas, no se puede cambiar la direccin de a. Expresiones apuntadoras como p+1, ++p y p+=i son vlidas. Double a[ ]; = double*a;
Cadenas
Las cadenas son arreglos unidimensionales de tipo char, Por convencin, una cadena en C se termina con centinela de fin de cadena carcter nulo \0. char s[ ]="ABC" char *p="a es por anon o pastel alfabeto" void main() { char *q="del cual todos tienen parte"; printf("\n%s,%s\n %s",s,p,q); ABC: a es por anon o pastel alfabeto del cual todos tienen parte. For(p=q;*q!='\0';++q) *q+=1 printf("\n %s\n\n",p); }
Arreglos multidimensionales
Expresiones equivalentes ab[i][i] *(b[i]+j) (*(b+i))[j] *((*(b+i))+J) (&b[0][0]+5i+j) Al definir la funcin, en el encabezamiento, la declaracin: Int (*v)[5]; Int c[7][9][2]; C[i][j][k] = (&c[0][0][0]+9*2+i+2*j+k) = int v[ ][5];
Ejercicios de punteros
1.- Cul es el valor de *p y *(p+2) en cada caso? a) int *p papa[4]={12,21,121,212}; p=papa; *p *(p+2) 12 121

b) char *ptero; char arreglo[7]={'C','L','A','U','D','I','O'}; ptero=arreglo; *ptero *(ptero+2) c) int *ptero; int arreglo[2][2]={{1,2},{3,4}}; *ptero *(ptero+2) d) int *ptero; static int arreglo [4]={1023,7}; *ptero *(ptero+2) 2.- Dado lo siguiente: int *p=&i | arreglo[5]={1,2,3,4,5}, *ptero; a) i=10, ptero=arreglo; i=*p+*ptero[4]; (ptero+2)=ptero+*ptero[4] i arreglo[2] b) i=10, ptero=arreglo i=(*p)+1+(*ptero)+2 ptero=*ptero+3+i i arreglo[0] 14 18 15 5 1023 0 1 3 'C' 'A'
USO DE TYPEDEF
C proporciona diversos tipos fundamentales, como char e int, y varios tipos derivados, como arreglos y punteros; tambin proporciona la declaracin typedef, que permite la asociacin explcita de un tipo con un identificador. Algunos ejemplos son: typedef int METROS, DECIMETROS, CENTIMETROS; typedef int vector[10]; En cada una de stas definiciones de tipo, los identificadores nombrados pueden usarse despus para declarar variables o funciones, del mismo modo en que se usan los tipos ordinarios; por ejemplo, METROS largo, ancho; declara que las variables largo y ancho son de tipo METROS, que, a su vez, equivale al tipo int. De esta manera, METROS puede emplearse como una declaracin de un tipo sinnimo de int.
Referencia Bibliografica:
Introduccin a la Programacion en C, Kelley/Pohl
SOLUCIONES A EJERCICIOS PLANTEADOS

Ejercicios resueltos parte 1: Estructuras e Instrucciones bsicas
1. #include<stdio.h> main() { int a,b; printf(Ingrese el primer valor \n); scanf(%d,&a); printf(Ingrese el segundo valor \n); scanf(%d,&b); printf(el resultado es : %d \n, a*b); } #include<stdio.h> main() { float a,b,mult; printf(Ingrese el primer valor \n); scanf(%f,&a); printf(Ingrese el segundo valor \n); scanf(%f,&b); mult=a*b; printf(El resultado es : %f \n, mult); } La principal diferencia entre la primera y la segunda solucin, es que la primera no puede efectuar una multiplicacin entre decimales. 2. #include<stdio.h> #define PI 3.1415 main() { float radio; printf(Ingrse el radio \n); scanf(%f,&radio); printf(El permetro es %f \n, PI * radio* 2.0); getchar(); } 3. #include<stdio.h> main() { float a,b; printf(Ingrese el largo del rectngulo \n); scanf(%f,&a);

printf(Ingrese el ancho del rectngulo \n); scanf(%f,&b); printf(El permetro del rectngulo es %f \n, 2*a + 2*b); printf(El rea del rectngulo es %f \n,a*b); }
4. #include<stdio.h> main() { float a,b,c,d,suma,mult,pro; printf(Ingrese el primer valor \n); scanf(%f,&a); printf(Ingrese el segundo valor \n); scanf(%f,&b); printf(Ingrese el tercer valor \n); scanf(%f,&c); printf(Ingrese el cuarto valor \n); scanf(%f,&d); suma=a+b+c+d; mult=a*b*c*d; pro=suma/4.0; printf(El resultado de la suma es : %f, de la mult es : %f , y el promedio es %f \n, suma, mult, pro); }
5. #include<stdio.h> void main() { float a,b,c,d,suma,mult,pro; printf(Ingrese el primer valor \n); scanf(%f,&a); printf(Ingrese el segundo valor \n); scanf(%f,&b); printf(Ingrese el tercer valor \n); scanf(%f,&c); printf(Ingrese el cuarto valor \n); scanf(%f,&d); suma=a+b+c+d; mult=a*b*c*d; pro=suma/4.0; printf(El resultado de la suma es : %f, de la mult es : %f, y el promedio es : %f \n,suma,mult,pro); } 6. scanf(%c,&a); // la variable a es de tipo entero, no char. scanf(%c,&d); // la variable d no esta definida

7. No esta definida la variable suma 8. Ejercicios resueltos parte 2: Estructuras de Control 1. #include<stdio.h> main() { int N, i , suma=0; printf("Ingrese el valor de N \n"); scanf("%d",&N); if(N>0) { i=1; while(i<=N) { suma=suma+cont*cont; i=i+1; } prinf(" El resultado de la suma es: %d\n",suma); } getchar(); } 2. #include<stdio.h> main() { int N, i, j, suma=0,pot; printf("Ingrese el valor de N \n"); scanf("%d",&N); if(N>0) { i=1; while(i<=N) { j=1; pot=1; while(j<=i) { pot=pot*i; j=j+1; } suma=suma+pot; i=i+1; } prinf(" El resultado de la suma es: %d\n",suma); } } 3. #include<stdio.h> main()

{ int N, i, j, suma=0,fact; printf("Ingrese el valor de N \n"); scanf("%d",&N); if(n>0) { i=1; while(i<=N) { j=1; fact=1; while(j<=i) { fact=fact*j; j=j+1; } suma=suma+fact; i=i+1; } prinf(" El resultado de la suma es: %d\n",suma); } } 4. #include<stdio.h> main() { int N, i, j, suma=0,pot=1; printf("Ingrese el valor de N \n"); scanf("%d",&N); if(N>0) { i=1; while(i<=N) { j=1;pot=1; while(j<i) { pot=pot*i; j=j+1; } suma=suma+pot; i++; } prinf(" El resultado de la suma es: %d\n",suma); } } 5. #include<stdio.h> #define STOP 15 main() {

int N, i,mayor; printf("Ingrese un valor \n"); scanf("%d",&N); mayor=N; i=1; while(i<=STOP) { printf("Ingrese un valor \n"); scanf("%d",&N); if(mayor>N) mayor=N; i=i+1; } printf("El numero mayor es %d \n",mayor); } 6. #include<stdio.h> #define STOP 20 main() { int N, i,mayor,min; printf("Ingrese un valor \n"); scanf("%d",&N); mayor=N; min=N; i=1; while(i<=STOP) { printf("Ingrese un valor \n"); scanf("%d",&N); if(N>mayor) mayor=N; else if(N<menor) menor=N; i=i+1; } printf("El numero mayor es: %d y el menor es:%d \n",mayor,min); getchar(); }
7. #include<stdio.h> main() { int i; float a,b,factA,factB_A; printf("Ingrese a \n"); scanf("%f",&a); printf("Ingrese b \n"); scanf("%f",&b); if(a>=0 && b>=a) { for(i=1,factA=1;i<=a;i++) factA=factA*i; for(i=1,factB_A=1;i<=(b-a);i++) factB_A=factB_A*i; printf("El resultado es:%f \n",factA/factB_A); } else printf("No se puede calcular \n"); } 8. #include<stdio.h> #define STOP 15 main() { int valor,contpares=0,i; i=1; while(i<=STOP) { printf(ingrese un valor \n); scanf(%d,&valor); if(!(valor%2)) contpares++; i++; } printf(La cantidad de pares es: %d \n,contpares); } 9. Este programa tiene un ciclo infinito, debido a que despus del while(i) , viene el termino de la sentencia ; es decir el programa jams alcanza la sentencia i--, por ello la expresin i , siempre es verdadera. 10. Este tambin es un ciclo infinito, ya que siempre est ejecutando la sentencia valor de i es : %d\n",i); , por lo que nunca alcanza el incremento i++; printf( El
Pgina :100 Claudio Gutirrez-Soto, Manuel Crisosto,

11. Calcular lo siguiente : 1+2+3+4+5+...+N #include<stdio.h> void main() { int suma,i,N; printf("Ingrese el valor de N \n"); scanf("%d",&N); if(N>0) { for(i=1 ,suma=0; i<=N ; i++) suma=suma+i; print("El resultado es %d \n",suma); } else printf("Corra de nuevo el programa e ingrese un entero positivo \n"); } 12. Calcular 12+22+32+42+...+N2 #include<stdio.h> main() { int suma,i,N; printf("Ingrese el valor de N \n"); scanf("%d",&N); if(N>0) { for(i=1 ,suma=0; i<=N ; i++) suma=suma+i*i; print("El resultado es %d \n",suma); } else printf("Corra de nuevo el programa e ingrese un entero positivo \n"); } 13. Crear un programa que calcule: 10+21+32+43+...+NN-1 #include<stdio.h> main() { int suma,i,j,pot=1,N; printf("Ingrese el valor de N \n"); scanf("%d",&N); if(N>0) { for(i=1 ,suma=0; i<=N ; i++) { for(j=1,pot=1 ; j<i ; j++) pot=pot*i;

suma=suma+pot; } print("El resultado es %d \n",suma); } else printf("Corra de nuevo el programa e ingrese un entero positivo \n"); } 14. Crear un programa que calcule: 11+22+33+44+..+Nn #include<stdio.h> void main() { int suma,i,j,N; printf("Ingrese el valor de N \n"); scanf("%d",&N); if(N>0) { for(i=1 ,suma=0; i<=N ; i++) { for(j=1,pot=1 ; j<=i ; j++) pot=pot*i; suma=suma+pot; } print("El resultado es %d \n",suma); } else printf("Corra de nuevo el programa e ingrese un entero positivo \n"); }
15. Crear un programa que calcule lo siguiente: 1!+2!+3!+4!+...+N! #include<stdio.h> main() { int suma,i,j,N,fact; printf("Ingrese el valor de N \n"); scanf("%d",&N); if(N>0) { for(i=1 ,suma=0; i<=N ; i++) { for(j=1,fact=1 ; j<=i ; j++) fact=fact*j; suma=suma+fact; } print("El resultado es %d \n",suma); } else printf("El valor ingresado no es un entero positivo \n"); }
16. Crear un programa que calcule: a b= a!/b!(b-a)! #include<stdio.h> main() { int i,a,b; float fact1,fact2,fact3,res; printf("Ingrese el valor de a \n"); scanf("%d",&a); printf("Ingrese el valor de b \n"); scanf("%d",&b); if(a>=0 && ((b-a)>=0)) { for(i=1,fact1=1 ; i<=a ; i++) fact1=fact1*i; for(i=1,fact2=1 ; i<=b ; i++) fact2=fact2*i; for(i=1,fact3=1 ; i<=(b-a) ; i++) fact3=fact3*i; res=fact1/(fact2*fact3); printf("El resultado de la operacin es : %f \n",res); } else printf("Los valores ingresados no permiten realizar la operacin \n"); } 17. Crear un programa que calcule lo siguiente: (a k)=s(s-1)(s-2)(s-3)(s-4)...(s-k+1)/k! (a 0)=1 s R+, k N U{0} #include<stdio.h> main() { int i,k; float S,x,fact; printf("Ingrese el valor de k \n"); scanf("%d",&k); printf("Ingrese el valor de S \n"); scanf("%d",&S); if(S>0 && K>=0) { if(k>S) printf("El resultado es 0 \n");

else{ for(i=1,x=1; i<=k ;i++) { if(i!=k) x=x*(S-i); else x=x*(S-K+1); } for(i=1,fact=1 ; i<=k ; i++) fact=fact*i; printf("El resultado de la operacin es : %f \n",x/fact); } else printf("Los valores ingresados no permiten realizar la operacin \n"); } 18. Crear un programa que calcule: 1(x1+1)/1!+2(x2+1)/2!+3(x3+1)/3!+...+N(xN+1)/N! #include<stdio.h> main() { int i,j; float x,fact,res,N; printf("Ingrese el valor de x \n"); scanf("%d",&x); printf("Ingrese el valor de N \n"); scanf("%d",&N); if(N>0) { for(i=1 ; i<=N ; i++) { for(j=1,pot=1 ; j<=i ; j++) pot=pot*x; for(j=1,fact=1 ; j<=i ; j++) fact=fact*x; res=res+(i*(pot-i))/fact; } printf("El resultado de la operacin es : %f \n",res); } else printf("Los valores ingresados no permiten realizar la operacin \n"); }
19. Crear un programa que calcule lo siguiente: n 3* i 2*i-1/(n-i)! i=1 #include<stdio.h> main() { int i,j; float suma,fact,pot,N; printf("Ingrese el valor de N \n"); scanf("%f",&N); if(N>0) { for(i=1,suma=0 ; i<=N ; i++) { for(j=1,pot=1; j<=(i*2-1); j++) pot=pot*i; for((j=1,fact=1 ; j<=(N-i) ; j++) fact=fact*j; suma=suma+((3*pot)/fact); } printf("El resulatdo de la operacin es %f \n",suma); } else printf("El valor ingresado no permite realizar la operacin \n"); } 20. Crear un programa que calcule lo siguiente: n i ( (2*i)/j ) i=1 j=1 #include<stdio.h> main() { int i,j,N; float res,suma=0.0; printf("Ingrese N \n"); scanf("%d",&N); if(N>0) { for(j=1 ;j<=N ; j++) for(i=1 ; i<=j ; i++) suma=suma+(2*i)/j; printf("El resultado es : %f \n",suma); }

else printf("El valor ingresado no es permitido \n"); } 21. Crear un programa que calcule: n i (2*j)i i=1 j=1 #include<stdio.h> main() { int i,j,N,pot,suma,k; printf("Ingrese N \n"); scanf("%d",&N); if(N>0) { for(j=1 ,suma=0;j<=N ; j++) { for(i=1 ; i<=j ; i++) for(k=1,pot=1 ; k<=i ; k++) pot=pot*(2*j); suma=suma+pot; } printf("El resultado es : %d \n",suma); } else printf("El valor ingresado no es permitido \n"); } 22. Crear un programa donde se ingresen 50 nmeros, muestre el mayor, menor, y cuantos de ellos son mltiplos de 5. #include<stdio.h> #define STOP 50 main() { int i,valor,mayor,menor,mult5=0; printf("Ingrese un valor \n"); scanf("%d",&valor); mayor=menor=valor; if(!(valor%5)) mult5++; for(i=2; i<= STOP ; i++) { printf("Ingrese un valor \n"); scanf("%d",&valor); if(valor>mayor) mayor=valor; else if( valor< menor) menor=valor;

if(!(valor%5)) mult5++; else continue; } printf(" El mayor es :%d, el menor es: %d y la cantidad de mult. de 5 son:%d\n"\mayor,menor,mult5);
} Solucin de Certamenes de aos anteriores

Solucin PCR23: CASO A (!(k>=j || k<=5) && (!(j=j-1 > k ) && ((i+1)==j/2)) ((3>=5 || 3<=5) && (!(j=3 > 3 ) && (5==2))) (!(FALSO || VERDADERO) && (!(FALSO) && (FALSO))) (!VERDADERO && (VERDADERO && (FALSO))) (FALSO && FALSO) (FALSO) CASO B (!(k>=j || k<=5) && (!(j=j-1 > k ) && ((i+1)==j/2)) (! (3>=7 || 3<=5) && (!(j=6 > 3 ) && (4==3))) (! (FALSO || VERDADERO) && (!(VERDADERO) && (FALSO))) (!VERDADERO && (FALSO && (FALSO))) (FALSO && FALSO) (FALSO)
Solucin PCR24:
N 6
i 1 2 3 4 5 6 7
cont 0 1
stop 1
SALIDA 1 0 0 0 0 0
Solucin PCR25 int i,j,suma1,suma2 Imprimir(Ingrese N) Leer(N) N 3 I 1 2 3 J 1 2 1 suma1 0 2 7 suma2 0 1 0

if(N>0) { suma1=0 for(i=1; i<=N ;i=i+1) { suma2=0 j=1 while (j<=i) { suma2=suma2+j j=j+1 } suma1=suma1+i+suma2 } Imprimir(suma1) } else { Imprimir(Error) } } 2 3 1 2 3 4 10 pts 16 5 pts 1 3 0 1 3 6 10 pts
5 pts
Ejercicios resueltos parte 3: Funciones
Solucin de Certamenes de aos anteriores

Solucin PCR31: #include <stdio.h> int n,j; int funcionX(int x); main() { for (j=4;j<=9;j++) { if (funcionX(j)==j) printf ("\n %d Si es !!",j); } } /* Funcion */ int funcionX(int x) { int i, suma; suma=0; i=1; while (i<x) { if ((x%i) = =0) suma=suma+i; i++; }; t ( ) main() Monitor funcionX i sum 1 1 2 3 3 4 1 1 2 3 4 5 1 1 2 3 3 6 4 5 6 1 1 2 3 4
j 4 5 6 7 8
x 4
6 5

5 6 7 1 2 3 4 5 6 7 8 1 2 3 4 5 6 7 8 9
1 3 7
1 4
Solucin PCR32: int sumatoria(int n) { int i, j; float suma=0.0, j, numerador,denominador; for(i=1,;i<=n;i++) { for(j=1,numerador=1.0;j<=i;j++) Numerador=numerador*(2*j-1); for(j=1,denominador=1.0;j<=i;j++) denominador= denominador * factorial(i+1); suma=suma+numerador/denominador; } return(suma); //2 ptos } Solucin PCR33:

int sumatoria(int n) { int i, j, fact, pot, suma=0; for(i=1,;i<=n;i++) { if(i%2==1) //significa que i es impar { for(j=1,fact=1; j<=i ;j++) // aqu calculo el factorial fact=fact*j; suma=suma+fact; } else { // significa que es par for(j=1, pot=1; j<=i; j++) // aqu calculo la potencia pot=pot*I; suma=suma+pot*-1; } } return(suma); //2 ptos } Solucin PCR34.: float Sumatoria(float n) { float i, suma=0.0,j,numerador, denominador; if( n>=1.0) { for(i=1.0 ; i<=n; i++) { for(j=1.0,numerador=1.0 ; j<=i; j++) numerador=numerador*(2*j-1); for(j=1.0,denominador=1.0 ; j<=i; j++) denominador=denominador*4*i; suma=suma+numerador/denominador; } return(suma); } else return (-1); // en el caso que n sea menor que 1.0 } Solucin PCR35:
#include<stdio.h>
Introduccin a la Programacin Departamento de Sistemas de Informacin Universidad del Bo-Bo float a,b,i,f,sumaf; float fx(float x); main() { do scanf("%f%f",&a,&b); while (a>b); sumaf=0; for (i=a;i<=b;i++) { sumaf=sumaf+fx(i); } printf("\nResultado: %f",sumaf); getchar();getchar(); } float fx(float x) { if (x>5) return((x*x*x-5*x)/(x-5)); else if (x<=1) return(-(x*x+10*x)/25); else return ((x*x+3*x)/(x-1)); }
Solucin PCR36: #include<stdio.h> float potencia(int base, int exp); float factorial(int n); main(void) { int n, i; float suma; do{ printf(Ingrese el varlor de n\n); scanf(%d,&n); }while(n<0); for(i=0,suma=0.0 ;i<=n; i++) suma=suma+potencia(i,i+2)/factorial(i+1); printf(El resultado es suma: %f \n,suma); } float potencia(int base, int exp) { int i; float pot=1.0; if (exp==0) return(1.0); else if(exp>=1)

{ for(i=1;i<=exp; i++) pot=pot*(float)base; } else { for(i=1;i<=exp*-1; i++) pot=pot*(float)base; pot=1/pot ; } return(pot); } float factorial(int n) { int i; float fact=1.0; if(n==0) return(1.0) else { for(i=1;i<=n;i++) fact=fact*(float)i; } return(fact); }
Ejercicios resueltos parte 4: Arreglos 1.int largo_cadena(char cadena[ ]) { int largo; for(largo=0 ; cadena[largo]!= '\0' ;largo++) continue; return(largo); } 2.int ContarCoincidencia(char cadena[ ],char caracter) { int i,cuenta=0; for(i=0; cadena[i]!='\0' ; i++) if(cadena[i]==caracter) cuenta++; else continue; return(cuenta); } 3.int contarvocales(char cadena[ ])

{ int i,contar; for(i=0,contar=0; cadena[i] !='\0' ; i++) if(cadena[i]=='a' || cadena[i]=='A') contar=contar+1; else if(cadena[i]=='e' || cadena[i]=='E') contar=contar+1; else if(cadena[i]=='i' || cadena[i]=='I') contar=contar+1; else if(cadena[i]=='o' || cadena[i]=='O') contar=contar+1; else if(cadena[i]=='u' || cadena[i]=='U') contar=contar+1; else continue; } 4.void concatenar(char cadena1[ ], char cadena2[ ]) { int i, j,largo; largo=strlen(cadena1); for(i=0,j=largo;cadena2[i]!='\0'; j++,i++) cadena1[j]=cadena2[i]; cadena1[j]='\0'; } 5.void InvertirCadena(char cadena[ ]) { char cadInv[ ]; int largo,i,j; largo=strlen(cadena); for(i=(largo-1),j=0; i>=0 ; j++,i--) cadInv[j]=cadena[i]; for(i=0 ; i<largo; i++) cadena[i]=cadInv[i]; cadena[i]='\0'; } 6.void CopiarCadena(char cadena1[ ] , char cadena2[ ]) { int i; for(i=0; cadena2[i]!=\0' ; i++) cadena1[i]=cadena2[i]; cadena1[i]='\0'; } 7.Pgina :113 Claudio Gutirrez-Soto, Manuel Crisosto,

void CopiarIesimo(char cadena1[ ], int iesimo, char cadena2[ ]) { int i, j=0; for(i=iesimo; cadena2[i]!='\0' ; i++,,j++) cadena1[j]=cadena2[i]; cadena1[j]='\0'; } 8.int CompararCadena(char cadena1[ ],char cadena2[ ]) { int i,largo1,largo2,iguales=1; largo1=srtlen(cadena1); largo2=strlen(cadena2); if(largo1==largo2) { for(i=0 ; i<largo2 && iguales ;i++) if(cadena1[i]!=cadena2[i]) iguales=0; else continue; return(iguales); } else return(0); } Otra forma sera: int CompararCadena(char cadena1[ ],char cadena2[ ]) { int i,largo1,largo2; largo1=srtlen(cadena1); largo2=strlen(cadena2); if(largo1==largo2) { for(i=0 ; cadena1[i]!='\0' ;i++) if(cadena1[i]!=cadena2[i]) return(0); else continue; return(1); } else return(0); } 9.int Mdiagonal(int Matriz[ ][10])

{ int i,j; for(i=0; i<10 ; i++) for(j=0;j<10;j++) { if(j!=i) if(Matriz[i][j]!=0) return(0); else if(Matriz[i][j]!=1) return(0); else continue; } return(0); } Otra forma puede ser int Mdiagonal(int Matriz[ ][10]) { int i,j, es=1; for(i=0; i<10 && es ; i++) { for(j=0;j<10 && es ;j++) { if(j!=i && Matriz[i][j]!=0) es=0; else if(i==j && Matriz[i][j]!=1) es=0; else continue; } } return(es); } 10.void Operator(int matriz[ ][3], int vector[ ]) { int i,j; for(i=0 ; i<3 ; i++) for(j=0 ; j<3 ; j++) matriz[i][j]=potencia(matriz[i][j],vector[j]); } int potencia(int base,int exp) { int i; if(exp>0) for(i=0; i<exp ; i++)

pot=pot*base; else if(exp==0) pot=1; return(pot); } 11.int vmpositiva(int matriz[][4]) { int i,j, es=1; for(i=0 ; i<4 && es ; i++) for(j=0; j<4 && es ; j++) if(matriz[i][j]<0) es=0; else continue; return(es); } 12 .int ProductoEscalar(int vector1[ ],int vector2[ ], int m) { int i,suma=0; for(i=0 ;i<m ; i++) suma=suma+vector1[i]*vector2[i]; return(suma); } 13.int MatrizSuperior(int matriz[][3]) { int i,j, es=1; for(i=0; i<3 && es ; i++) for(j=0; j<3 && es; j++) { if(j>i && matriz[i][j]!=0) es=0; else if(j<=I && matriz[i][j]!=1) es=0; else continue; } return(es); } 14.int verificarSubMat(int Mat[ ][3],int vector[ ]) {

int i,j,temp[3]; // aqu verificamos las filas for(i=0; i<3 ; i++) { for(j=0 ; j<3 ; j++) temp[j]=Mat[i][j]; if(comparar(temp,vector,3)) return(1); else continue; } //aqu verificamos las columnas for(i=0; i<3 ; i++) { for(j=0 ; j<3 ; j++) temp[j]=Mat[j][i]; if(comparar(temp,vector,3)) return(1); else continue; } return(0); } int comparar(int vectMat1[ ],int vector[ ], int m) { int i; for(i=0 ;i<m ;i++) if(vectMat|[i]!=vector[i]) return(0); else continue; return(1); } 15.void intercambio(int fila, int FilaColumna, int FilaColumna2, int Matriz[ ][4]) { int temp[4],j; // el argumento fila es una bandera que indica que lo que se va a intercambiar son // filas o columnas. Si fila toma un valor distinto de 0, entonces lo que se //intercambia son las filas, sino las columnas. if(fila) { for(j=0 ; j<4 ; j++) temp[j]=Matriz[FilaColumna][j]; for(j=0 ; j<4 ; j++) Matriz[FilaColumna][j]=Matriz[FilaColumna2][j]; for(j=0 ; j<4 ; j++)

Matriz[FilaColumna2][j]=temp[j]; } else { for(j=0 ; j<4 ; j++) temp[j]=Matriz[j][FilaColumna]; for(j=0 ; j<4 ; j++) Matriz[j][FilaColumna]=Matriz[j][FilaColumna2]; for(j=0 ; j<4 ; j++) Matriz[j][FilaColumna2]=temp[j]; } } 16.int AnalizadorSintactico(char arreglo[ ]) { char p1; int seguir=1,i; for(i=0 ; arreglo[i]!=\0 && seguir ; i++) { p1=ObtenerChar(arreglo,i); if(p1==( || p1==) || p1==+ || p1==- || p1==* || p1==\ || (p1>=0 || && p1<=9) continue; else seguir=0; } return(seguir); } char ObtenerChar(char arreglo[ ],int i) { int largo; largo=strlen(arreglo); if(i<largo) return(arreglo[i]); else return(j); } 17.int AnalizadorSemantico(char arreglo[ ]) { int i, seguir=1,largo; char v1,v2; largo=strlen(arreglo); for(i=0 ; i<(largo-2) && seguir ; i++) { v1=ObtenerChar(arreglo,i); v2=ObtenerChar(arreglo,i+1);

if(v1==() { if(v2!=) && v2!=+ && v2!=* && v2!=- && v2!=/ ) continue; else seguir=0; } else if(v1==)) { if(v2!=( && ((v2>=0 && v2<=9))) continue; else seguir=0; } else if(v1==+ || v1==- || v1==/ || v1==*) { if((v2>=0 && v2<=9) || ( ) continue; else seguir=0; } else if(v1>=0 && v1<=9) { if(v2!=( && v2!=) ) continue; else seguir=0; } } if((largo-2)>=0) { if((largo-2)==0) { if(arreglo[0]>=0 && arreglo[0]<=9) { if(arreglo[1]>=0 && arreglo[1]<=9) return(seguir); else seguir=0; } else seguir=0; } else return(seguir); } else if(largo==1) { if(arreglo[0]>=0 && arreglo[0]<=9) return(seguir); else seguir=0; } else seguir=0; return(seguir);

}
Solucin de Certamenes de aos anteriores Solucin PCR41:

Retorna la vocal que ms se repite Solucin PCR42: #include<stdio.h> int Mayoritario(int elem, int vector[], int n); void imprimir(int mayoritario, int vector[], int n); main(void) { int i,mayoritario,stop=0; //suponemos que el vector se ingreso for(i=0;i<n && !stop ;i++) { May_=vector[i]; if(Mayoritario(May_, vector, n)) stop=1; else continue; } if(stop==1) { printf(el elemento mayoritario es %d\n, May_); printf(Los minoritarios son \n); Imprimir(May_,vector,n); } else { printf(No existe elemento mayoritario\n); for(i=0;i<n ;i++) printf(%d,vector[i]); } return(0); } int Mayoritario(int elem, int vector[], int n) { int cont=0, i; for(i=0; i<n; i++) if(elem==vector[i]; cont++; else continue; return(cont>n/2); void imprimir(int mayoritario, int vector[], int n) { int i; for(i=0;i<n;i++)

if(vector[i]!=mayoritario) printf( %d, vector[i]); else continue; } Solucin PCR43:
#include<stdio.h> #include<string.h> #define MAX 5 InicializarMatriz(char MatSec[][MAX]); void Traspasar(char MatSec[][MAX],char fraseSec[]); void CodMsje(char MsjeACod[],char MsjeCdo[], char MatSec[][MAX]); void imprimir(char mat[][MAX]); int main(void) { char fraseSec[50],MatSec[MAX][MAX]; char MsjeACod[50]; char MsjeCdo[50]; printf("Ingrese la frase secreta\n"); gets(fraseSec); InicializarMatriz(MatSec); Traspasar(MatSec,fraseSec); printf("Ingrese el mensaje a codificar\n"); gets(MsjeACod); CodMsje(MsjeACod, MsjeCdo, MatSec); printf("El mensaje codificado es %s\n", MsjeCdo); return(0); } void Traspasar(char MatSec[][MAX],char fraseSec[]) { int largo, i,j,k,esta,stop; largo=strlen(fraseSec); for(k=0; k<largo; k++) { esta=0; for(i=0; i<MAX && !esta ; i++) for(j=0; j<MAX && !esta ; j++) { if(fraseSec[k]==MatSec[i][j] ) esta=1; } if(esta==0) { for(i=0,stop=0; i<MAX && !stop ; i++) for(j=0; j<MAX && !stop ; j++) { if(MatSec[i][j]=='0' && fraseSec[k]!=' ') { MatSec[i][j]=fraseSec[k]; stop=1; } } }else continue; } }

void CodMsje(char MsjeACod[],char MsjeCdo[], char MatSec[][MAX]) { int largo,i,j,k,m,esta; largo=strlen(MsjeACod); for(k=0 ,m=0; k<largo; k++) { esta=0; for(i=0; i<MAX && !esta ; i++) for(j=0; j<MAX && !esta ; j++) { if(MsjeACod[k]==MatSec[i][j] ) { esta=1; if( (j+1)<MAX) if(MatSec[i][j+1]!='0') MsjeCdo[m++]= MatSec[i][j+1]; else if(MatSec[i+1][0]!='0') MsjeCdo[m++]= MatSec[i+1][0]; }//fin del if }// fin del for if(esta==0) MsjeCdo[m++]= MsjeACod [k]; else continue; } MsjeCdo[m]='\0'; } InicializarMatriz(char MatSec[][MAX]) { int i,j; for(i=0; i< MAX;i++) for(j=0; j< MAX;j++) MatSec[i][j]='0'; }
Solucin PCR44: #include <stdio.h> #define n 4 int buscar(int x); int x, a[n]; main() { int i,j; printf(" Ingrese los numeros al arreglo "); for (i=0;i<n;i++) scanf("%d",&a[i]); printf(" Ingrese el nmero a analizar :"); scanf("%d",&x); if (buscar(x)) printf(" Si existen "); else printf(" NO existen"); getchar(); getchar(); }

int buscar(int x) { int i,j,b=0; for (i=0;(i<n) && (b==0);i++) for (j=i+1;(j<n) && (b==0);j++) if (x==a[i]+a[j]) { b=1; printf("Los numeros son : %d y %d",a[i],a[j]); }; if (b==0) return(0); else return(1); } Solucin PCR45: #include <stdio.h> int NOTAS[40], i, j, snotas=0; prom=0,ca=0; char NOMBRE[40] [20]; main() { //Ingreso de NOTAS Y NOMBRES. Se asume que existe mas de un alumno for (i=0;i<40&&NOTAS[i]!=-1;i++) { ca++; snotas=snotas+NOTAS[i] } prom=snotas/ca; printf (\nLISTADO DE ALUMNOS SOBRE EL PROMEDIO\n) for (i=0;i<ca;i++) { if (NOTAS[i]>=prom) for (j=0;j<20;j++) printf(%c,NOMBRE[i][j]); printf((\n) } printf (\n LISTADO DE ALUMNOS BAJO EL PROMEDIO \n) for (i=0;i<ca;i++) { if (NOTAS[i]<prom) for (j=0;j<20;j++) printf(%c,NOMBRE[i][j]); printf((\n) } getchar();getchar(); } Solucin PCR46: #include<stdio.h> int vector[1000],n,i,j,mayoritario,ctamayoritario,ctapaso; main() { do {

printf("\nIngrese Cantidad de Elementos"); scanf("%d",&n); }while((n<1)||(n>1000)); for (i=0;i<n;i++) scanf("%d",&vector[i]); mayoritario=vector[0]; ctamayoritario=0; for (i=0;i<n-1;i++) { ctapaso=1; for (j=i+1;j<n;j++) if (vector[i]==vector[j]) ctapaso=ctapaso+1; if (ctapaso > ctamayoritario) { ctamayoritario=ctapaso; mayoritario=vector[i]; } } if (ctamayoritario > (n/2)) printf("\nElemento Mayoritario : %d", mayoritario); else printf("\nNO EXISTE ELEMENTO MAYORITARIO"); } int fmayoritario(int vec[1000], int dim,int *b) { int i,j,m,cm,cp; m=vector[0]; cm=0; for (i=0;i<dim-1;i++) { cp=1; for (j=i+1;j<dim;j++) if (vec[i]==vec[j]) cp=cp+1; if (cp > cm) { cm=cp; m=vec[i]; } } if (cm > (dim/2)) return (m); else *b=0; } Solucin PCR47:
#include<stdio.h> #include<conio.h> char m[20][20],p[20],bas; int n1,n2,i,j,b,b2,f,c,k ; FILE *dat; int Comparar(char patronAux[],char patron[]); void Copiar_IesimoInv(char Mat[][20], int i, int j, int fila, int largo, char patronAuxInv[]); void Copiar_Iesimo(char Mat[][20], int i, int j, int fila, int largo, char patronAux[]); int Esta(char Mat[][20], char patron[]); int ObtenerLargo(char patron[]); main() { //para probar completo el ingreso lo realice via archivo dat=fopen("datos.txt","r"); fscanf(dat,"%c",&bas);

for (i=0;i<20;i++) { for (j=0;j<20;j++) { fscanf(dat,"%c",&m[i][j]); } fscanf(dat,"%c",&bas); } fclose(dat); for (i=0;i<20;i++) { for (j=0;j<20;j++) { printf("%c",m[i][j]); } printf("\n"); } printf("\nIngrese Elementos a buscar: "); gets(p); k=Esta(m,p); if (k==1) printf("\n cadena SI esta!"); else printf("\n cadena No esta!"); getchar(); getchar(); } int Esta(char Mat[][20], char patron[]) { int i,j, largo, fila; char patronAux[20], patronAuxInv[20]; largo=ObtenerLargo(patron); // Busqueda por fila for(i=0, fila=1; i<20 ; i++) for(j=0; j<20 ; j++) { if((patron[0]==Mat[i][j] && (i-19)<=largo)) { Copiar_Iesimo(Mat, i, j, fila, largo, patronAux); if( (i+1) >=largo) { Copiar_IesimoInv(Mat, i, j, fila, largo, patronAuxInv); if( Comparar(patronAuxInv, patron)) return(1); } if( Comparar(patronAux, patron)) return(1); } } // fin de bsqueda por fila // Bsqueda por Columna for(i=0, fila=0; i<20 ; i++) for(j=0; j<20 ; j++) { if(patron[0]==Mat[i][j] && (j-19)<=largo) { Copiar_Iesimo(Mat, i, j, fila, largo, patronAux); if( (i+1) >=largo) { Copiar_IesimoInv(Mat, i, j, fila, largo, patronAuxInv); if( Comparar(patronAuxInv, patron)) return(1); } if( Comparar(patronAux, patron)) return(1); } } // fin de bsqueda por columna return (0); // no est } int ObtenerLargo(char patron[])

{ int i; for(i=0; patron[i]!='\0' ;i++); return(i); } void Copiar_Iesimo(char Mat[][20], int i, int j, int fila, int largo, char patronAux[]) { int k,L,m; if(fila==1) { // j es la columna for(k=j, m=0; m<largo; k++, m++) patronAux[m]=Mat[i][k]; patronAux[m]='\0'; } else { // i es la fila for(k=i, m=0; m<largo; k++, m++) patronAux[m]=Mat[k][j]; patronAux[m]='\0'; } } void Copiar_IesimoInv(char Mat[][20], int i, int j, int fila, int largo, char patronAuxInv[]) { //char patronAux[20]; int k,L,m; if(fila==1) { // j es la columna for(k=j, m=0, L=largo; L>0; L--, m++,k--) patronAuxInv[m]=Mat[i][k]; patronAuxInv[m]='\0'; } else { // i es la fila for(k=i, m=0, L=largo; L>0 ; L--, k--, m++) patronAuxInv[m]=Mat[k][j]; patronAuxInv[m]='\0'; } } int Comparar(char patronAux[],char patron[]) { int i, es=1; for(i=0;patron[i]!='\0' && es ; i++) if(patron[i]!=patronAux[i]) es=0; else continue; return(es); }
Solucin PCR48:
void Consulta(int Puntos[][n], int n, int q1, int q2, int R[][n],float r) // 6 ptos { int k,i ; float dist ; for(i=0,k=0 ;i<n ;i++) { dist=sqrt(((q1-Puntos[i][0])* (q1-Puntos[i][0]))+ (q2-Puntos[i][1])* (q2-Puntos[i][1]))); //15 if(dist<=r) //3 { R[k][0]=Punto[i][0]; // 2

R[k][1]=Punto[i][1]; // 2 k++; } else continue; }
Solucin PCR49:
void Estado(char Depositos[][N], char NCuenta[], int mes) // 3 ptos { int i,j; char NCuentaAux[5]; char Monto[5]; for(i=0,suma=0;i<N;i++) //2 { Copiar_Iesimo(Depositos[i],0,5, NCuentaAux); // 7 ptos if(!strcmp(NCuentaAux,NCuenta) && mes==Depositos[i][5]) { Copiar_Iesimo(Depositos[i],6,5, Monto); // 7 ptos Monto_entero=atoi(Monto); // 6 Suma=suma+Monto_entero; // 5 } printf(El monto:%d para el NCuenta %s\n,Monto_entero,NCuenta); }
Ejercicios resueltos parte 5: Estructuras

1.struct complejos{ float real; float imaginario; }; typedef struct complejos COMPLEX; COMPLEX asignar(float Real , float Imag) { COMPLEX a; a.real=Real; a.imaginario=Imag; return(a); } 2.COMPLEX suma(COMPLEX a , COMPLEX b) { COMPLEX z; z.real=a.real+b.real; a.imaginario=a.imaginario+b.imaginario return(z); } 3.COMPLEX mult(COMPLEX a , COMPLEX b) { COMPLEX z; z.real=a.real*b.real-a.imaginario*b.imaginario; z.imaginario=a.real*b.real+a.imaginario*b.real; return(z); } 4.- void mostrar(char facultda[ ]) { int i; for(i=0 ; i<3 ; i++) { if( !(strcmp(facultad,PER[i].CodCarreF))) { printf(Nombre : %s \n,PER[i].nombre); printf(rut : %s \n,PER[i].nombre); printf(Trabajo : %s \n,PER[i].nombre); } else continue; }

} 5.- int contar(char facultad[ ]) { int i, totalF; for(i=0 , totalF=0 ; i<300 ; i++) { if(!(strcmp(facultad,PER[i].codcarreraF))) totalF++; else continue; } return(totalF); } 6.- void mostrar(char facultad[ ], char trabajo[ ]) { int i; if(!(strcmp(facultad,PER[i].codcarreraF)) && !(strcmp(PER[i].codtrabajo,trabajo))) { printf(Nombre : %s \n,PER[i].nombre); printf(rut : %s \n,PER[i].rut); } else continue; } 7.struct Facultad{ char CodCarreraF[5]; char Descripcion[20]; }; typedef struct{ char CodTrabajo[20]; char descripcion[20]; }trabajo; typedef struct{ char codcalidad[20]; char Descripcion[20]; }Calidad;
typedef struct{ char codcarreraF[5]; char rut[10];


char nombre[20]; char codtrabajo[20]; char codcalidad[20], float sueldo; }Personal; 8.1) void ingresar_notas(char Ramo[]) { int i,j; for(i=0;i<300;i++) if(!(strcmp(Ramo,ALUMN[i].ramo))) { for(j=0;j<3;j++) { printf(Ingrese la nota %d para el rut %s \n,j+1,ALUMN[i].rut2); scanf(%f,&ALUMN[i].Notas[j]); } } else continue; } 8.2) void calcular_promedio(char Ramo[]) { int i; for(i=0;i<300;i++) if(!(strcmp(Ramo,ALUMN[i].ramo))) ALUMN[i].promedio=(ALUMN[i].Notas[0]+ ALUMN[i].Notas[1]+ ALUMN[i].Notas[2])/3; else continue; } 8.3) void mostrar_examen(char Ramo[]) { int i,j,DebeDarExamen; for(i=0;i<300;i++) { if(!(strcmp(Ramo,ALUMN[i].ramo))) { if(ALUMN[i].promedio>=50) { if(ALUMN[i].Notas[0]<40 || ALUMN[i].Notas[1]<40 || ALUMN[i].Notas[2]<40 ) DebeDarExamen=1; else if((ALUMN[i].Notas[0]<50 && ALUMN[i].Notas[1]<50) && (ALUMN[i].Notas[0]<50) && ALUMN[i].Notas[2]<50) (ALUMN[i].Notas[1]<50 && ALUMN[i].Notas[2]<50)) DebeDarExamen=1; else DebeDarExamen=0; }

else DebeDarExamen=1; if(DebeDarExamen) { for(j=0;j<30;j++) { if(!strcmp(ALUMN[i].rut2,DATOS[j].rut)) printf(El alumno %s , se presenta a examen con promedio %f \n, DATOS[j].nombre,ALUMN[i].promedio); else continue; } } }/*if*/ else continue; }/*for*/ }/* funcion */

Apunte de Introduccion A La Programacion UBB

Cargado por

Información del documento

Título original

Derechos de autor

Formatos disponibles

Compartir este documento

Compartir o incrustar documentos

Opciones para compartir

¿Le pareció útil este documento?

¿Este contenido es inapropiado?

Copyright:

Formatos disponibles

Apunte de Introduccion A La Programacion UBB

Cargado por

Copyright:

Formatos disponibles

INTRODUCCIN A LA PROGRAMACIN

Claudio Gutirrez-Soto Manuel Crisosto Muoz

Introduccin a la Programacin Departamento de Sistemas de Informacin Universidad del Bo-Bo Agradecimientos

Pgina : 2 Claudio Gutirrez-Soto, Manuel Crisosto,

Introduccin a la Programacin Departamento de Sistemas de Informacin Universidad del Bo-Bo

Pgina : 3 Claudio Gutirrez-Soto, Manuel Crisosto,

Introduccin a la Programacin Departamento de Sistemas de Informacin Universidad del Bo-Bo

Introduccin a la Programacin Departamento de Sistemas de Informacin Universidad del Bo-Bo

Pgina : 5 Claudio Gutirrez-Soto, Manuel Crisosto,

Introduccin a la Programacin Departamento de Sistemas de Informacin Universidad del Bo-Bo

Programa que permite resolver la ecuacin de primer grado

Pgina : 6 Claudio Gutirrez-Soto, Manuel Crisosto,

Introduccin a la Programacin Departamento de Sistemas de Informacin Universidad del Bo-Bo

Pgina : 7 Claudio Gutirrez-Soto, Manuel Crisosto,

Introduccin a la Programacin Departamento de Sistemas de Informacin Universidad del Bo-Bo

Ejercicio 0.1: Cree un algoritmo que multiplique tres nmeros.

Pgina : 8 Claudio Gutirrez-Soto, Manuel Crisosto,

Introduccin a la Programacin Departamento de Sistemas de Informacin Universidad del Bo-Bo

Entero var1, x , y Real a, b Escribir Mensaje 1

Lectura de mensajes Transformacin de datos Operaciones sobre los datos

Bifurcacin en la ejecucin de instrucciones

Pgina : 9 Claudio Gutirrez-Soto, Manuel Crisosto,

Ingrese el primer valor

Ingrese el segundo valor

Pgina : 10 Claudio Gutirrez-Soto, Manuel Crisosto,

Introduccin a la Programacin Departamento de Sistemas de Informacin Universidad del Bo-Bo

Usted es mayor de edad

Pgina : 11 Claudio Gutirrez-Soto, Manuel Crisosto,

Introduccin a la Programacin Departamento de Sistemas de Informacin Universidad del Bo-Bo

Introduccin a la Programacin Departamento de Sistemas de Informacin Universidad del Bo-Bo

Instruccin a F mientras (expresin) Inicio Instruccin 1 Instruccin 2

expresin V Instruccin 1 Instruccin 2

Instruccin n Fin Instruccin b

CICLO REPETIR (INSTRUCCIONES) MIENTRAS

Introduccin a la Programacin Departamento de Sistemas de Informacin Universidad del Bo-Bo

Instruccin a do Inicio Instruccin 1 Instruccin 2

Instruccin N V Instruccin n Fin mientras (expresin) Instruccin b

Ciclo Repetir . Mientras

Pgina : 14 Claudio Gutirrez-Soto, Manuel Crisosto,

Introduccin a la Programacin Departamento de Sistemas de Informacin Universidad del Bo-Bo

Instruccin a Para ( Vc=Vi; Vf / Condicin; Salto) Inicio Instruccin 1 Instruccin 2

Ciclo Para (variables de control)

Escribir Ingrese un numero entero:

Pgina : 15 Claudio Gutirrez-Soto, Manuel Crisosto,

Introduccin a la Programacin Departamento de Sistemas de Informacin Universidad del Bo-Bo

Pgina : 16 Claudio Gutirrez-Soto, Manuel Crisosto,

Introduccin a la Programacin Departamento de Sistemas de Informacin Universidad del Bo-Bo

Entero a,b,x Real fx

Entero a,b,x Real fx

Escribir Ingrese los valores de a y b

Escribir Ingrese los valores de ay b

Escribir a debe ser menor que b

F x=a,x<=b, inc 1 x=a,x<=b, inc 1

fx = (3*x*x+5*x-2) / 125 fx = (3*x*x+5*x-2) / 125

Pgina : 17 Claudio Gutirrez-Soto, Manuel Crisosto,

Uso de repetir mientras y ciclo para

Pgina : 18 Claudio Gutirrez-Soto, Manuel Crisosto,

Introduccin a la Programacin Departamento de Sistemas de Informacin Universidad del Bo-Bo

No se incluirn las respuestas de este apartado.

Introduccin a la Programacin Departamento de Sistemas de Informacin Universidad del Bo-Bo

PARTE 1: ESTRUCTURA E INSTRUCCIONES BSICAS EN EL LENGUAJE C

Pgina : 20 Claudio Gutirrez-Soto, Manuel Crisosto,

Introduccin a la Programacin Departamento de Sistemas de Informacin Universidad del Bo-Bo

fx = (3xx+5x-2) / 125 fx = (3xx+5x-2) / 125