apunte de introducción a la programación .pdf (claudio gutiérrez-soto)

INTRODUCCIÓN A LA PROGRAMACIÓN

Claudio Gutiérrez-Soto Manuel Crisosto Muñoz

Introducción a la Programación Departamento de Sistemas de Información Universidad del Bío-Bío

Página : Claudio Gutiérrez-Soto, Manuel Crisosto,

2

Agradecimientos Quiero agradecer de manera anticipada a los alumnos de introducción a la programación, de quienes esperamos recibir feedback para mejorar este apunte con el objeto de que en algún momento sea un texto de apoyo a la programación. Segundo, quiero agradecer a mi colega y amigo Manuel Crisosto quien ha hecho importantes contribuciones con ejemplos y ejercicios, así como también para que este apunte llegue a mano nuestros alumnos. Además quiero agradecer a mis colegas Pedro Campos y Christian Vidal por sus aportes en la preparación de los certamenes así como de las clases.

Claudio Gutiérrez-Soto



3

Prólogo Estimados alumnos, el material que se presenta a continuación está diseñado para apoyar la asignatura de introducción a la programación que tienen como objetivo el lograr resolver problemas simples mediante un programa escrito en algún lenguaje de programación. Como ustedes pondrán ver el conjunto de símbolos, instrucciones y estructuras presentes en un algoritmo o programa son fáciles de identificar y aprender en relación a su significado. La dificultad se presenta al intentar combinar lógicamente estas instrucciones y estructuras para que resuelvan un problema planteado. El objetivo general es resolver problemas básicos a través de la construcción de programas basados en algoritmos. Un algoritmo lo podemos definir como un conjunto de pasos lógicamente ordenados, escritos a través de símbolos 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 precisión 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 instrucción escrita en un lenguaje de programación. En el diseño e implementación 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 capítulo se presentarán 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 mayoría de los algoritmos o programas requiere que se le ingresen datos que serán transformados, convenientemente por el conjunto de instrucciones, en la salida que se esta solicitando. Es imprescindible poder identificar estos datos de entrada y la información de salida que se está solicitando.

3. Identificar las posibles restricciones o condiciones que se deben consideran para los datos de entrada.

4. Construcción del algoritmo o programa. Sin embargo, lo más importante que podemos recalcar en la utilización de este libro, es que la adquisición de la destreza para poder resolver un problema a través de un algoritmo es paulatina y progresiva. Es decir, hay que ejercitar con el objeto de adquirir la lógica 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 través de ejercicios. En dicho caso, nuestra herramienta es el computador, compilador y simuladores asociados.



4

Parte 0: Introducción.............................................................................................................5

Programa ..........................................................................................................................5 Algoritmo...........................................................................................................................6 Variables ...........................................................................................................................6

Concepto de Ciclo ..............................................................................................................13 Ciclo Mientras (expresión) ..............................................................................................13 Ciclo Repetir (instrucciones) Mientras ............................................................................13 Ciclo Para (variables de control): ....................................................................................14 Ejercicios parte 0: Construcción de algoritmos ...............................................................19

Parte 1: Estructura e instrucciones básicas en el lenguaje C.............................................20 Función 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 Proposición switch ..........................................................................................................34 Proposición while ............................................................................................................38 Ejercicios parte 2: Ciclo while .........................................................................................41 Proposición for ................................................................................................................42 Ejercicios parte 2 ciclos for .............................................................................................45 Proposición do while ......................................................................................................46 PREGUNTAS DE CERTAMENES DE AÑOS ANTERIORES al 2008, REFERENTES AL MANEJO DE CICLOS Y EVALUACIONES LÓGICAS ...................................................47

Parte 3: Definición de una función......................................................................................51 Pasaje de parámetros o argumentos ..............................................................................59 PREGUNTAS DE CERTAMENES DE AÑOS ANTERIORES al 2008, REFERENTES AL MANEJO DE FUNCIONES.............................................................................................61

Parte 4: Arreglos Unidimensionales ...................................................................................65 Inicialización de arreglos.................................................................................................65 Cadenas o Strings...........................................................................................................67 Arreglos bidimensionales ................................................................................................69 Ejercicios Parte 4: Arreglos.............................................................................................72 PREGUNTAS DE CERTAMENES DE AÑOS ANTERIORES al 2008, REFERENTES AL MANEJO DE ARREGLOS, CADENAS Y MATRICES....................................................74

Parte 5: Estructuras ............................................................................................................82 Declaración 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 parámetros de una función ................................................................85 Ejercicios parte 5: Estructuras ........................................................................................86

Parte 6: Punteros................................................................................................................89 Uso de typedef....................................................................................................................94 Soluciones a ejercicios planteados.....................................................................................95



5

PARTE 0: INTRODUCCIÓN

Conceptos básicos

PROGRAMA Un programa computacional, en términos simples, consiste en una serie de pasos lógicamente escritos que permiten resolver un problema determinado, que a partir de datos de entrada obtiene información útil para la toma de decisiones. Aprender a programar consiste, por un lado, en conocer las distintas instrucciones que un determinado lenguaje de programación tiene, y más importante aún, escribir un conjunto de instrucciones en forma lógica para que la ejecución de estas instrucciones permita dar respuesta al problema planteado. No basta con conocer las instrucciones existentes, se debe adquirir la lógica que permite utilizarlas con un fin específico. La mayoría de los problemas que se resuelven en el transcurso de un curso de programación 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 solución • Diseñar solución • Implementar solución • Validar solución

La siguiente figura simplifica los pasos anteriores, para esto supongamos que queremos construir un programa que permita resolver la ecuación de primer grado.



6

El primer paso es entender que se está pidiendo, esto requiere de la máxima atención, pues de lo contrario difícilmente 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 información de salida. Además, se debe poder definir algunas restricciones, para este ejemplo que a debe ser distinto de cero. A continuación se recomienda escribir un algoritmo que represente una aproximación a la solución final. Posterior a estos pasos se traduce el algoritmo a un lenguaje de programación determinado.

ALGORITMO Un algoritmo consiste en un procedimiento detallado, escrito en forma simbólica o con lenguaje natural, para resolver un problema en pasos y en un tiempo finito. Algunas características de los algoritmos son:

• el algoritmo lleva desde un estado inicial a un estado final • se especifican en base a operaciones básicas 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 específicas de la memoria del computador. Estos datos pueden ser ingresados por ejemplo desde teclado (datos de entrada), o ser datos intermedios producto de alguna transformación (procesamiento) para producir la salida requerida (información). Los lenguajes de programación utilizan diversos tipos de datos los cuales determinan la cantidad de memoria a ocupar en el computador. Entre estos datos tenemos:

Programa que permite resolver la ecuación de primer grado

a x + b = 0

? a b

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 solución es %d:”,x); } printf(“Fin programa”); }

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 solución es:”,x) Fin Escribir(“Fin programa”) Fin

a ≠ 0



7

Tipo de dato Propósito Entero Permite almacenar valores de tipo entero. Real o flotante Permite almacenar números fraccionarios. Lógico Permite almacenar los valores lógicos de verdad, Verdadero o Falso. Carácter Permite almacenar cualquier carácter 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 nemotécnico 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 posición de memoria con el nombre “suma”,

• si se quiere calcular la ecuación de primer grado, los datos de entrada conviene almacenarlos en las posiciones con nombre a, b; y el resultado de la evaluación en x.

Recordemos que para resolver un problema, se debe tener claro cuales son los datos de entrada y salida; además de estos se pueden utilizar datos intermedios necesarios para el procesamiento. Todos estos datos se deben declarar, al inicio del programa o, como veremos más adelante, al inicio de cada sección del programa.



8

La forma en que se ejecutan las operaciones básicas en un computador, es similar a lo que ocurre en nuestro cerebro. Por ejemplo, para sumar dos valores, los pasos básicos son:

• Primero debemos pedirle a alguien que nos diga el primer valor. • Luego de que conocemos este valor, debemos almacenarlo (para recordarlo después) 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 números. De lo anterior podemos decir que:

• al menos necesitamos 3 neuronas para sumar dos números. • pedimos explícitamente que nos dijeran dichos valores. • asignamos dichos valores a las neuronas • la suma la realizó nuestro cerebro de forma mecánica. • Finalmente se da el resultado

Por lo tanto el algoritmo básico para sumar dos números podría ser el siguiente: • Algoritmo para sumar dos números:

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 programación no se usan neuronas, pero podemos definir variables (recuerde que las variables pueden tomar cualquier valor según 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. También 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 posición de memoria. Ejercicio 0.1: Cree un algoritmo que multiplique tres números.

Datos de Entrada: tres números (x1,x2,x3) Información de Salida: Suma de x1,x2 y x3 Restricciones: Ninguna

Algoritmo para multiplicar tres números: • 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 multiplicación de las variables en

var4 • Entregamos e l resultado que se encuentra en var4.



9

La manera en que se han detallado los dos algoritmos se llama pseudo-código, el cual fue escrito en lenguaje natural (nuestro lenguaje, entendible por el ser humano). Otra manera de poder detallar lo algoritmos, es a través de los diagrama de flujo. Un diagrama de flujo es una representación simbólica de la lógica del algoritmo. Existen un conjunto de símbolos básicos utilizados en la constricción de diagramas de flujo, los cuales tienen su equivalente en pseudo-código, y lo más importante su correspondiente traducción en un lenguaje de programación.

Como hemos mencionado anteriormente, no basta con saber el significado de cada símbolo, debemos saber como combinar estos símbolos para producir un algoritmo que resuelva el problema planteado.

Inicio

Escribir “Mensaje 1”

Fin

Leer var1,x, y

a = 3 * x + y b = a / var1

Entero var1, x , y Real a, b

Si a > b V F

Inicio de Algoritmo

Definición de variables

Impresión de mensajes

Lectura de mensajes

Transformación de datos Operaciones sobre los datos

Bifurcación en la ejecución de instrucciones

Conector

Fin de algoritmo

DIAGRAMA DE FLUJO NOMENCLATURA PSEUDO-CÓDIGO

Inicio

Variables Entero var1, x, y Real a, b

Escribir (“Mensaje 1”)

Leer (var1, x, y)

a = 3 * x + y b = a / var1

Si a > b Entonces Inicio Instrucciones…

Fin Sino Inicio Instrucciones… Fin

Fin



10

Ejemplo 0.2: El siguiente algoritmo, escrito utilizando diagrama de flujo permite sumar dos números y muestra el resultado por pantalla (o monitor) Entrada: Dos números (x1 y x2) Salida: x1+x2 Restricciones: Ninguna

Observación: En los ejemplos de este apartado, incluiremos el código en lenguaje C con el objetivo de que lo prueben, modifiquen, adapten, corrijan, etc.

Inicio

Termino

int var1,var2 ,var3

Ingrese el primer valor

var 1

Ingrese el segundo valor

var 2

var3=var1+var2

El resultado es : var3

En pseudos-código: 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

El lenguaje C: #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); }



11

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 (sólo uno de estos mensajes) Restricciones: Edad no puede ser negativa, ni mayor a 200 (esto no es validado en este algoritmo).

Del ejemplo anterior podemos observar que la bifurcación permite seguir el flujo adecuado dada una condición. La condición que se evalúan en una bifurcación 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 condición sea falsa, esto dependerá del problema que se este resolviendo. También es posible que existan bifurcaciones contiguas.

v

f

En pseudos-código: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

Termino

Usted es menor de edad

Usted es mayor de edad



12

En las bifurcaciones o estructura de control, se evalúan proposiciones utilizando: • Operadores lógicos: And, or y not • Operadores aritméticos: *, / , +, - , %1 • Operadores Relacionales: == (igual), != (distinto), > (mayor que), < (menor que), >= (mayor igual), <= (menor igual)

Recordemos que los operadores lógicos están definidos según el algebra booleana y arrojan un valor de verdadero o falso según las proposiciones que forman la expresión. La siguiente tabla de verdad nos muestra las posibles combinaciones que se puede presentar (supongamos que las proposiciones son P1 y P2).

(P1) (P2) (P1) and (P2) (P1) or (P2) Not (P1) V V V V F V F F V F F V F V V F F F F V

Además, cada expresión puede estar formada por una o más proposiciones unidas por operadores lógicos, a estas expresiones les llamaremos expresiones compuestas. Ejemplo 0.4: Evaluación de una expresión compuesta Asumamos la siguiente expresión: ((P1 and P2) or P3) and (not P3)) Para determinar la veracidad o falsedad de esta expresión debemos saber el valor de verdad de cada proposición, la cual puede cambiar en el transcurso del tiempo. La tabla de verdad asociada a esta expresión 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 V F F V V F V V V V V F V F V F F V F F F F V F F V V F V F F F V F F F V F F F V F V F F F F F F F V F

Hasta ahora los algoritmos descritos son secuenciales, es decir se ejecuta una instrucción, y al término de ésta se ejecuta la siguiente, excepto cuando existe una bifurcación, en cuyo caso se podría saltar un grupo de instrucciones dependiendo de la evaluación de la condición. El control de ejecución es siempre “hacia delante”. Existen aplicaciones en las cuales se requiere repetir un número determinado de instrucciones, en cuyo caso, una o más instrucciones se ejecutarán de acuerdo a determinadas condiciones, a estas estructuras presentes en los algoritmos se les denomina ciclos.

1 Corresponde a la función modulo que entrega el resto de la división entre dos enteros.



13

CONCEPTO DE CICLO Un ciclo es la repetición de un conjunto de instrucciones. Dicho ciclo culmina cuando se cumple una condición de término. El grupo de instrucciones se pueden ejecutar un número conocido o desconocido de veces. CICLO MIENTRAS (EXPRESIÓN): Esta estructura se utiliza cuando se quiere repetir un conjunto de instrucciones mientras se cumpla una determinada condición la cual es evaluada al comienzo del ciclo. El grupo de instrucciones se ejecutará como mínimo cero veces (la expresión evaluada es falsa), o una o más veces (la expresión evaluada es verdadera, y se espera que esta cambie en el transcurso de la ejecución del grupo de instrucciones)2. En el diagrama de flujo se utiliza la estructura de bifurcación, y cuando termina de ejecutarse el grupo de instrucciones, el control del algoritmo retorna a la bifurcación, produciéndose una nueva evaluación de la expresión. El esquema siguiente ilustra la forma que toma este ciclo utilizando diagrama de flujo y pseudos-código.

Ciclo Mientras

CICLO REPETIR (INSTRUCCIONES) MIENTRAS La diferencia con el ciclo anterior es que la expresión se evalúa al término de la ejecución del grupo de instrucciones que se necesitan repetir, tal como lo muestra el esquema siguiente.

2 Si esto no se cumple, es decir la expresión inicialmente es verdadera y no cambia se producira un ciclo infinito o loop infinito.

Instrucción a

Instrucción 1

Instrucción N

expresión

Instrucción 2

V

Instrucción b

F

Instrucción a mientras (expresión) Inicio Instrucción 1 Instrucción 2 Instrucción n Fin Instrucción b



14

Ciclo Repetir …. Mientras En las estructuras anteriores el número de veces que se repetirán las instrucciones no necesariamente es conocido (esto depende la lógica del algoritmo). Existen muchas ocasiones en que se conoce el número de veces que se desea repetir el grupo de instrucciones, por ejemplo leer 100 números. En estos casos es aconsejable utilizar el ciclo “Para”. CICLO PARA (VARIABLES DE CONTROL): En este ciclo el número de veces que se repite el conjunto de instrucciones es conocido, y el control de la repetición es asumido por un conjunto de variables de control. El esquema siguiente representa esta estructura en diagrama de flujo y pseudos-código. 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.

Instrucción a

Instrucción 1

Instrucción N

expresión

Instrucción 2

V

Instrucción b F

Instrucción a do Inicio Instrucción 1 Instrucción 2 Instrucción n Fin mientras (expresión) Instrucción b



15

Ciclo Para (variables de control)

A continuación de verán algunos ejemplos para clarificar estas estructuras.

Instrucción a

Instrucción 1

Instrucción N

Instrucción 2

Instrucción b

Vc = Vi , Vf / Condición, Salto

Instrucción a Para ( Vc=Vi; Vf / Condición; Salto) Inicio Instrucción 1 Instrucción 2 Instrucción n Fin Instrucción b

Algoritmo Tabla de Multiplicar Variables Entero a,b Inicio Escribir (“Ingrese un número entero:”) Leer (a) b=0 Para (b=0; b<a; salto 1) Inicio Escribir (a,b,a*b) Fin Fin

Inicio

Entero a,b

Escribir “Ingrese un numero entero:”

Leer (a)

b ← 0

b=0,b<a, inc 1

Escribir a, b, a*b

Fin

#include <stdio.h> Int a, b; main() { printf(“Ingrese un número entero:”); scanf(“%d”,&a); for(b=0;b<a;b=b+1) { printf(“%d * %d = %d,a,b,a*b); } }

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



16

Observación: Revisar este algoritmo y realizar un seguimiento. Qué sucede cuando se ingresa un número 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 instrucción) se ejecuta mientras se cumpla la condición 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 características del ciclo Para:

• El incremento puede ser un valor negativo o positivo, entero o decimal, unitario o no unitario.

• La expresión además de la variable de control puede contener más proposiciones, esto dependerá de la lógica 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 función 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



17

La primera solución 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 solución 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 continuación se escribe los pseudo-código de ambos diagramas de flujo y sus correspondientes programas en C.

Inicio

Entero a,b,x Real fx

Escribir“Ingrese los valores de ay b”

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

Escribir x, fx

Leer (a,b)

Fin

x=a,x<=b, inc 1

Si a > b V

F

Si a < b VF

Inicio

Entero a,b,xReal fx

Escribir “Ingrese los valores de a y b”

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

Escribir x, fx

Leer (a,b)

x=a,x<=b, inc 1 Escribir “a debe ser menor que b”

Fin



18

Uso de bifurcación y ciclo para 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”) 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

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



19

EJERCICIOS PARTE 0: CONSTRUCCIÓN DE ALGORITMOS3 Construya los siguientes algoritmos 1. Que multiplique tres números ingresados desde teclado y muestre el resultado 2. Que divida dos números y muestre el resultado 3. Que muestre en forma ordenada tres número enteros ingresados desde teclado. 4. Que resuelva la ecuación de primer grado y muestre el resultado 5. Que resuelva la ecuación de segundo grado, para valores reales e imaginarios, y muestre el resultado. 6. Que permita sumar “n” números y muestre el resultado. El valor de “n” debe ser ingresado por teclado al igual que los números que se sumarán. 7. Que permita el ingreso de 15 números y que cuente cuántos de los números ingresados son pares. 8. Que permita el ingreso de 15 números 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

3 No se incluirán las respuestas de este apartado.



20

PARTE 1: ESTRUCTURA E INSTRUCCIONES BÁSICAS 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 librería stdio.h, la cual posee

las funciones de entrada y salida de datos. Existen múltiples librerías para propósitos específicos.

main() main(), es la función principal de C, ella siempre debe estar presente.

{ Comienza el cuerpo del programa printf(“Este es mi primer programa en C.”); La función printf( ), se encarga de mostrar o desplegar

el contenido que se encuentra entre las comillas en el monitor.

getchar(); Función que espera a que se presione una tecla } Fin del programa. Este programa debe ser compilado para su ejecución. El proceso de compilación, en términos simples, corresponde a la traducción del programa “fuente” a su equivalente en lenguaje “objeto” o lenguaje de “máquina”. El compilador realiza un análisis sintáctico del programa. Una vez compilado, arrojará en pantalla:

Este es mi primer programa en C.

Ejemplo 1.1 #include<stdio.h> main() { printf(“hola mundo.”); }

En pantalla :

Hola mundo.

FUNCIÓN PRINTF() La función 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.



21

Ejemplo 1.2 : En este ejemplo se muestran las diferentes cadenas de control para la función printf

#include<stdio.h> main() { printf(“Ahora utilizaremos los caracteres de control\n”); printf(“El siguiente carácter salta a una nueva línea. \n”); printf(“ \t El carácter utilizado es un tabulador. \n”); printf(“ \“ Esta frase esta entre comillas. \” \n”); printf(“ El siguiente carácter representa retorno de carro : \r \n”); printf(“ \‘ Esta frase esta entre apóstrofes. \’ \n”); printf(“ \\ Esta frase esta entre barras invertidas \\ \n”); printf(“Los siguientes caracteres representan retrocesos :\b\b\b\b\b\b \n”); }

A continuación se imprimirá lo siguiente en pantalla:

Ahora utilizaremos los caracteres de control El siguiente carácter salta a una nueva línea

El carácter utilizado es un tabulador. \“ Esta frase esta entre comillas. \” El siguiente carácter representa retorno de carro ‘ Esta frase esta entre apóstrofes. \ \\ 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, documentación o acotaciones a líneas de códigos o al programa general, la forma de utilizarlos es:

/* Este es un comentario, el cual generalmente involucra 2 o más lineas de código */ // Este es otro comentario que involucra 1 sola línea 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 impresión.

#include<stdio.h> main() { int entero=1; // declaración de una variable entera // llamada entero, con valor 1. float comaflotante =1.56356789; 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 carácter es : %c \n”, caracter); printf(“ %s \n”, cadena);

Se imprimirá lo siguiente en pantalla: El valor del entero es : 1 El valor del flotante es : 1.56356789; El valor del carácter es : a Esta es una cadena



22

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.

CARÁCTER TIPO DE DATO c Carácter d Entero s String (conjunto de caracteres) e Flotante en notación científica f Flotante g e ó f más corto.

Otro ejemplo, donde podemos utilizar las opciones de visualización de las variables, es el siguiente Ejemplo 1.4 #include<stdio.h> main() { float i=56.111111111; printf(“El valor de i es : %f \n”,i); printf(“El valor de i es : %5f \n”,i); printf(“El valor de i es : %15f \n”,i); printf(“El valor de i es : %.1f \n”,i); printf(“El valor de i es : %.5f \n”,i); printf(“El valor de i es : %.0f \n”,i); printf(“El valor de i es : %e \n”,i); 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

Ejemplo 1.5: En este ejemplo se muestran los caracteres de control, salto de línea, retoceso y tabulación. #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”

*** *** *** *** ***



23

Entre otras características del printf( ), podemos encontrar. Ejemplo 1.6: Aquí se muestra que es posible realizar las operaciones matemáticas básicas 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); }

Esto imprimirá : La suma de la variable a+b es : 7.

Función scanf() El scanf( ) es la función que permite recibir datos ingresados a través de teclado. Ejemplo 1.7: La función scanf también utiliza caracteres para los distintos tipos de datos. Obsere que son los mismos caracteres que utiliza la función printf.

#include<stdio.h> #include<conio.h> //librería que contiene la función 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 función 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 deberán llevar el & en el argumento de la función (osea después de la coma). Como en el ejemplo, scanf(“ %d”, &a); Ejemplo 1.8 Aquí se muestra que también es posible ingresar varios datos a la vez con la función 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 carácter \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); }



24

DEFINE El uso de define, se utiliza para declarar variables con un valor fijo (también denominada constante), el cual puede ser utilizado en el resto del programa. Las líneas 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 línea #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 términos generales, las constantes simbólicas ayudan en la documentación al reemplazar lo que de otra forma sería una constante enigmática con un identificador nemotecnico, hacen más portátil 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 verificación de la representación 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 simbólica. main() { float radio; printf(“Ingrese el radio \n”); scanf(“%f”,&radio); printf(“El área del círculo es : %f \n”, PI * radio * radio); getchar(); } El programa del ejemplo calculará el área del círculo, reemplazando PI, por el valor flotante 3.1415

INCREMENTO Y DECREMENTO En C, existen los operadores matemáticos 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: --



25

Ejemplo 1.10 Aquí se muestra la aplicación 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 después 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 después de las variables que se incrementan o decrementan.

OPERADORES

++ (incremento) -- (decremento) - (unario) * (multiplicación) / (división) %(módulo) +(suma) — (resta) = (asignación)

Como mencionamos previamente, existe una diferencia entre : ++i; y i++; al momento de utilizar otros operadores de incremento y decremento. La operación de modulo (a % b) entrega el resto de la división entre los enteros a y b.



26

EJERCICIOS Crear los siguientes programas: 1. Ingresar dos números y multiplicarlos. 2. Ingresar el radio de una circunferencia y calcular su perímetro. 3. Ingresar el largo y ancho de un rectángulo y calcular el área y perímetro. 4. Ingresar el radio y el alto para obtener el volumen de un cilindro. 5. Ingresar cuatro números, obtener la suma, multiplicación y promedio.



27

Dado los siguientes códigos: 6. ¿Qué errores presenta el siguiente programa?

#include<stdio.h> main() { int a, b; printf(“Ingrese el primer número \n”); scanf(“%c”,&a); printf(“Ingrese el segundo número \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();

}



28

PARTE 2: ESTRUCTURA DE CONTROL. Las estructuras de control permiten “romper” el orden lineal de ejecución de las instrucciones (una a continuación de la otra), permitiendo bifurcar en dos o más caminos la ejecución de las instrucciones, o repetir un número conocido o desconocido de veces un conjunto de instrucciones. En estas estructuras se utilizan (expresiones) formadas por operadores relacionales y operadores lógicos.

Operadores Relacionales Operadores Lógicos < Menor ! Negación > Mayor && Y lógico

<= Menor o igual || O lógico >= Mayor o igual == Igual != Distinto

LA ESTRUCTURA DE CONTROL IF La estructura de control if permite bifurcar la ejecución de instrucciones en dos caminos Sintaxis : if (expresión) sentencia V // se ejecutan estas sentencias si evaluación de la expresión es verdadera else sentencia F // se ejecutan estas instrucciones si la evaluación de la expresión es falsa

donde:

expresion Proposicion1 TipoOperador Proposicion2 TipoOperador ....ProposicionN TipoOperador Operador lógico ó OperadorMatemático ó OperadorRelacional.

Ejemplo 2.1: Ingrese 2 números y muestre la división : 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”);



29

} En este ejemplo comenzamos a utilizar la proposición if. Dentro de esta proposición nos encontramos con el operador lógico distinto !=, ya que como sabemos cualquier número dividido por cero es indeterminado. Resumiendo, si el divisor es distinto de cero, se hará la división, 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 líquido de una persona. Sin embargo, si la persona es de la I o XII región, 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 ó duodécima sueldoB=sueldoB*1.35; // región 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 líquido 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 número es par o imparr, para ello se utiliza el operador módulo %. Entrada: X Salida : Mensaje 1: El número es par Mensaje 2: El número es impar Restricciones: no tiene

#include<stdio.h> main() { int numero; printf(“Ingrese un número \n”); scanf(“%d”,&numero); if(!(numero%2))



30

printf(“El número es par \n”); else printf(“El número es impar \n”);

} Cualquier número par, al dividirlo por 2 su residuo es 0., es decir el módulo es 0.

Ejemplo 2.4 En este ejemplo se ingresan tres números 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 número \n”); scanf(“%d”, &a); printf(“Ingrese el segundo número \n”); scanf(“%d”, &b); printf(“Ingrese el tercer número \n”); scanf(“%d”, &c); if(a>b) if(a>c) printf(“El número mayor es %d \n”,a); else printf(“El número mayor es %d \n”,c); else if(b>c) printf(“El número mayor es %d \n”,b); else printf(“El número mayor es %d \n”,c);

}

Ejemplo 2.5 En este ejemplo se ingresan tres números y se muestra el mayor, para ello se utiliza la sentencia if –else anidados, en conjunto con el operador lógico 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 número \n”); scanf(“%d”, &a); printf(“Ingrese el segundo número \n”); scanf(“%d”, &b); printf(“Ingrese el tercer número \n”); scanf(“%d”, &c); if(a>b && a>c) printf(“El numero mayor es %d \n”,a); else if(b>c) printf(“El número mayor es %d \n”,b); else printf(“El número mayor es %d \n”,c);

getchar();



31

}

Ejemplo 2.6 En este ejemplo se ingresa un número entero y se muestra el valor absoluto de dicho número. Entrada: x Salida : Valor absoluto de x Restricciones:no tiene

#include<stdio.h> main() {

int x; printf(“Ingrese un número \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 números 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


int a,b,c,min,max; printf(“Ingrese el primer número \n”); scanf(“%d”, &a); printf(“Ingrese el segundo número \n”); scanf(“%d”, &b); printf(“Ingrese el tercer número \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 número mayor es %d y el menor es %d ºn”, max,min); }



32

Ejemplo 2.8 Este ejemplo al igual que el anterior, se ingresan tres números y se muestran el mayor y el menor. Entrada: a,b,c Salida : se imprime el mayor y el menor Restricciones: no tiene


int a,b,c,min,max; printf(“Ingrese el primer número \n”); scanf(“%d”, &a); printf(“Ingrese el segundo número \n”); scanf(“%d”, &b); printf(“Ingrese el tercer número \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 número mayor es %d y el menor es %d ºn”, max,min); }



33

Ejemplo 2.9 Este ejemplo muestra la solución para la ecuación cuadrática. Aquí se utiliza la librería math.h, la cual contiene la función sqrt. La función sqrt calcula la raíz cuadrada de un valor. Entrada: a,b,c Salida : x1 y x2 (las soluciones de la ecuación) 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 númericos 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 número del 0-9 \n”); scanf(“%d”,&valor); if(valor >=0 && valor <=9) if(valor==1) printf(“El número ingresado es el uno \n”); else if(valor==2) printf(“El número ingresado es el dos \n”); else if(valor==3) printf(“El número ingresado es el tres \n”); else if(valor==4) printf(“El número ingresado es el cuatro \n”); else if(valor==5) printf(“El número ingresado es el cinco \n”);



34

else if(valor==6) printf(“El número ingresado es el seis \n”); else if(valor==7) printf(“El número ingresado es el siete \n”); else if(valor==8) printf(“El número ingresado es el ocho \n”); else printf(“El número ingresado es el nueve \n”);

else printf(“El valor ingresado esta fuera del rango \n”);

}

PROPOSICIÓN SWITCH switch es una proposición condicional múltiple que generaliza a la proposición if-else. Lo siguiente es la estructura del switch

switch (expresión) { case 'caso_1': sentencias; break; case 'caso_2': sentencias; break; case 'caso_3': sentencias; break; case 'caso_N': sentencias; break; default: sentencias;

} Obsérvese que la proposición switch está encerrada entre llaves. Después de evaluar la expresión, el control salta a la etiqueta apropiada (al correspondiente case). Todos los case son exclusivos, es decir reflejan un caso particular. Por lo común, la última proposición antes de la siguiente case es break. Con este break nos aseguramos que la ejecución del caso termine allí. Si no hay una proposición break, la ejecución 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 proposición etiquetada default. Esto indica que si la evaluación de switch no coincide con ninguna etiqueta, entonces toma en cuenta el default.



35

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, opción Salida : x1 opción 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 división ó 4 multiplicación \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 están evaluando corresponde a enteros y no a caracteres.



36

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 división por cero, esto no es posible). Entrada : x1,x2, opción Salida : Mensaje 1: x1 opción x2 Mensaje 2: No se puede dividir por cero (en caso que se quiera dividir dos números) Restricciones: Si se divide, x2 no puede ser cero No se puede ingresar una opción 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 división ó 4 multiplicación \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 opción no valida \n"); else printf("No se puede dividir por 0 \n");

}



37

Ejemplo 2.13: Crear un programa donde el usuario ingrese un número del 1 al 9, y se muestre en pantalla el texto asociado al número, pero utilizando la proposición switch. Entrada : x Salida : x escrito en palabra Restricciones: 0 ≤ x ≤ 9 #include<stdio.h>

main() { int valor; printf(“Ingrese un número del 0-9 \n”); scanf(“%d”,&valor); switch(valor) { case 1 : printf(“El número ingresado es el uno \n”); break; case 2: printf(“El número ingresado es el dos \n”); break; case 3: printf(“El número ingresado es el tres \n”); break; case 4: printf(“El número ingresado es el cuatro \n”); break; case 5: printf(“El número ingresado es el cinco\n”); break; case 6: printf(“El número ingresado es el seis\n”); break; case 7: printf(“El número ingresado es el siete \n”); break; case 8: printf(“El número ingresado es el ocho \n”); break; case 9: printf(“El número ingresado es el nueve \n”); break; default: printf("Ha ingresado un valor no válido \n"); }

getchar(); }



38

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 operación con caracteres. Entrada : x1,x2, opción Salida : Mensaje 1: x1 opción x2 Mensaje 2: No se puede dividir por cero (en caso que se quiera dividir dos números) Restricciones: Si se divide, x2 no puede ser cero No se puede ingresar una opción 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 división ó M multiplicación \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 opción no váida \n");

}

PROPOSICIÓN WHILE

Es una construcción de la forma:

while (expresión) proposición(es) a repetir

proposición que no se repite



39

Primero se evalúa expresión; si es falso (o es el valor cero), el control pasa directamente a proposición siguiente (proposición que no se repite), pero si es verdadero (o el valor es distinto de cero), entonces se ejecuta (proposición a repetir), y el control se devuelve al principio del ciclo while. De este modo, proposición se ejecuta cero (ña expresión es falsa en la primera evaluación) o varias veces hasta que expresión sea falsa, en ese momento, el control pasará a la proposición que no se repite. El efecto de esto es que la proposición puede ejecutarse cero, una o más veces. Es posible que, sin advertirlo, se especifique una expresión 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 situación debe tenerse cuidado.

Ejemplo 2.14: Crear un programa que calcule el factorial de un número 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 número 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 números negativos no existen \n”); }

Ejemplo 2.14:Una alternativa al problema anterior #include<stdio.h> main()

{ int contador,numero,fact=1; printf(“Ingrese el número 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 números negativos no existen \n”); getchar();



40

} 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 número 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 número 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


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 número 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).



41

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 números y muestre el mayor de todos. 6.- Crear un programa donde se ingresen 20 números 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 números 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++;

}



42

PROPOSICIÓN FOR Sintaxis: for (expresión1 ; expresión2 ; expresión3) proposición verdadera; proposición siguiente; o for (expresión1 ; expresión2 ; expresión3) { proposición verdadera1; proposición verdadera2; …. proposición verdaderaN; } proposición siguiente; Primero se evalúa expresión1 (lo usual es que expresión1 inicie el ciclo); después, se evalúa expresión2, si la expresión 2 es verdadera (o posee un valor distinto de 0) entonces se ejecuta la proposición verdadera o el conjunto de expresiones verdaderas. Note que el conjunto de expresiones verdaderas está compuesto por más de una expresión verdadera y por lo tanto debe de llevar las llaves { }. Posterior al ejecutar la proposición o proposiciones verdades, entonces se ejecuta la expresión 3, la cual generalmente aumenta o disminuye la variable, o variables que condicionan el ciclo. Posteriormente se vuelve a evaluar la expresión2, si esto es verdadero se vuelve a ejecutar la proposición o conjunto de proposiciones verdaderas, donde posteriormente se evalua la expresión3. Note que la expresión1, sólo se ejecuta la primera vez, luego la expresión2 y expresión3 se peueden ejecutar muchas veces mientras la expresión 2 sea verdadera.

Finalmente, si la expresión2 es falsa (o posee un valor 0), entonces se ejecuta la proposición 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(); }



43

Ejemplo 2.17: Crear un programa que calcule el factorial de un número 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 número 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 números 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 número 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 número que ingreso es incorrecto\n”); }



44

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


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 número 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 número ingresado no es mayor que 0 \n”);

}



45

EJERCICIOS PARTE 2 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 números, muestre el mayor, menor, y cuantos de ellos son múltiplos de 5.



46

PROPOSICIÓN 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 números y pueda ejecutar cualquiera de las operaciones basicas. Si se desea salir se debe ingresar 0. Entrada : x1,x2, opción Salida : Mensaje 1: x1 opción x2 Mensaje 2: No se puede dividir por cero (en caso que se quiera dividir dos números) Restricciones: Si se divide, x2 no puede ser cero No se puede ingresar una opción 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 válido \n"); } printf("Ingrese 0 para terminar y cualquier número para continuar \n"); scanf("%d",&opcion); }



47

while(opcion); }

PREGUNTAS DE CERTAMENES DE AÑOS ANTERIORES AL

2008, REFERENTES AL MANEJO DE CICLOS Y

EVALUACIONES LÓGICAS A continuación se lista algunas preguntas que se encuentran en certamenes anteriores, estás preguntas están con sus respuestas al final del apunte. PCR23.- Pregunta 1. Primer Certamen, Segundo Semestre 2007, 10 ptos. Dada la siguiente expresión:

!( k>=j || k<=5) && (!(j=j-1 > k ) && ((i+1)==j/2)) Evalúe los valores de verdad (es decir, si el resultado es verdadero o falso) tanto al interior de cada paréntesis, como en la expresión 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 iteración, 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”

} }



48

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 iteración, 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

I

J

suma1

suma2

A continuación se lista algunas preguntas que se encuentran en certamenes anteriores, estás preguntas están 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 }

N

i pot exp Imprime:



49

PCP 2.- Dado los siguientes algoritmos, obtenga los valores de las variables que aparecen en la tabla en cada iteración. a)

N i j stop suma

4

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

b)

N i j k printf

1

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”

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 cálculo, tanto en diagrama de flujo como en seudo-código



50

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 número\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) b) c) d) e) 1 5 10 11 Ninguno de los

anteriores PCP 5.- Pregunta 2. Examen, Primer Semestre 2006, 20 ptos Considerando el siguiente trozo de código:

i = 0; while (i < 29) { if (i == 29) printf(“%d”, i);

i++; } ¿Qué valor se imprime en la salida estándar (pantalla)? Justifique su respuesta.



51

PARTE 3: DEFINICIÓN DE UNA FUNCIÓN

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 monolítico (es decir, un programa compuesto de un único módulo) no puede ser fácilmente abarcado por un lector. El número de caminos de control, la expansión de referencias, el número de variables y la complejidad global podrían hacer imposibles su correcta compresión. Para ilustrar este punto, consideremos la siguiente disquisición, basada en observaciones sobre la resolución humana de problemas. Sea C(x) una definición de la complejidad de un problema x y E(x) una función que define el esfuerzo (en tiempo) requerido para resolver un problema x. Para dos problemas, p1 y p2, si

C(p1) > C(p2) 1.a

se deduce que E(p1) > E(p2) 1.b Para un caso general, este resultado es intuitivamente obvio. Se tarda más tiempo en resolver un problema difícil. Se ha encontrado otra propiedad interesante, a partir de la experimentación sobre la resolución humana de problemas. Se trata de lo siguiente: C(p1 + p2) > C(p1) + C(p2) 1.c La ecuación 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 condición 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 conclusión del tipo "divide y vencerás". Por consiguiente deberemos considerar las funciones como "CAJAS NEGRAS", las cuales se encargaran de ejecutar una tarea específica. Por lo tanto deberemos concentrarnos en el "Diseño Global de programa" en lugar de los detalles. La estructura de una función es como sigue:

tipo_de_funcion nombre_de_la_funcion (argumentos) { Cuerpo de la Función return(variable ó valor); /* opcional solo cuando la función es de tipo void*/ }



52

Donde el tipo_de_funcion corresponde al tipo de datos que retorna ó devuelve dicha función, la cual puede ser del tipo entero ( int ) , flotante (float), carácter (char ) etc, además es importante aclarar que aquellas funciones que no son definidas, por defecto son de tipo entero. argumentos: corresponde a valores recibidos por la función, los cuales también se deben definir de un tipo determinado, como si se tratase de una definición de variable común y corriente, cabe destacar además que no necesariamente una función debe recibir un valor, si no que esta puede estar vacía. La estructura de los argumentos pueden ser: nombre_de_la_funcion (tipo_dato arg1,tipo_dato arg2,...,tipo_dato argN) ó también: nombre_de_la_funcion(arg1, arg2,..., argN) tipo_dato arg1,tipo_dato arg2,...,tipo_dato argN; { Cuerpo de la Función

return(variable ó valor); }

Cuerpo de la función: Corresponde al código fuente que se encargará de realizar el proceso, aquí se deberán declarar variables si fuese necesario, dichas variables son denominadas variables locales porque pertenecen a esa función y sólo existen cuando el compilador toma dicha función, dejando de existir cuando el compilador termina de ejecutar dichas líneas de código. 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 función donde halla sido llamada, es importante destacar que una variable ó valor único. Más adelante veremos como retornar variables que tengan asociados más de un valor, por lo que por el momento sólo nos quedaremos con la proposición inicial. Algunas veces no necesitaremos que las funciones nos retornen un valor, por lo que podremos omitir esta sentencia. A continuación veremos algunos ejemplos de cada caso:



53

Ejemplo 3.1 Crear un programa utilizando funciones donde se sumen dos números. 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 función suma. Las variables locales sólo tienen existencia durante la ejecución de la respectiva función. Pueden existir variables locales con el mismo nombre en distintas funciones las cuales estarán 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 parámetros y el //valor devuelto por la función 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 función suma, las variables a,b no han sido declaradas porque son argumentos (declaración implícita por los argumentos), sólo 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);



54

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 función 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 función que entregue el número mayor de dos números. 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 número \n"); scanf("%d",&valor1); printf("Ingrese un segundo valor \n"); scanf("%d",&valor2); printf("El número mayor es %d \n",mayor(valor1,valor2)); }



55

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 número \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 número mayor es %d \n",a); else printf("El número mayor es %d \n",b); } Ejemplo 3.6: Crear un programa que calcule la suma, resta, multiplicación o división según selección del usuario, utilizando funciones. Entrada: a,b,opcion Salida: a+b, o a-b, o a*b, o a/b

Restricciones: Si la opción es división 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;



56

printf("Ingrese a \n"); scanf("%f",&a); printf("Ingrese b \n"); scanf("%f",&b); printf("Ingrese 1 para sumar o,2 resta, 3 mutiplicación,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 opción no válida \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); }



57

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, sólo 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);



58

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 válido \n"); } float potencia(int a,int b) { int i,pot=1; if(b>=0) {



59

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 PARÁMETROS O ARGUMENTOS Los valores que se le entregan como entrada a las funciones se conocen como párametros. Por ello, al momento de utilizar o llamar una función, se indica el nombre de la función junto con los párametros reales (valores específicos). También es importante acotar que algunas funciones no podrían llevar argumentos, por lo que en ese caso los paréntesis de la función pueden quedar vacias. Cuando un programa llama a una función la información importante se comunica a través de la lista de parámetros y se establece una correspondencia automática entre los parámetros reales y formales. Los parámetros reales son “sustituidos” por los parámetros 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 ... // parámetros reales }

int suma(int c, int d) // c y d corresponden a // los parámetros formales { return (c+d); }

Existen métodos diferentes para el paso de parámertos a funciones. Es preciso conocer la disponibilidad y la forma en que los lenguajes de programación apoyan este concepto. Un mismo programa puede producir distintos resultados bajo diferentes formas de paso de parámetros.



60

Revisaremos dos tipos de paso de parámetro, por valor y por referencia.

Por valor Por referencia En este caso los parámetros se tratan como variables locales y los valores de los parámetros reales se copian en los correspondientes parámetros formales. Los cambios que se produzcan en los parámetros por efecto del subprograma (función) no afectan a los argumentos originales.

El módulo que llama envía la dirección de memoria del parámetro real. Entonces una variable pasada como parámetro por referencia puede ser modificada directamente por el subprograma. En lenguaje C, cuando se realiza un paso de parámetro por referencia el argumento se precede del símbolo &.

Como ejemplo se pide comparar los siguientes códigos:

Por valor 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; }

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



61


2008, REFERENTES AL MANEJO DE FUNCIONES A continuación se lista algunas preguntas que se encuentran en certamenes anteriores, estás preguntas están 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.

main() funcionX j Monitor x i sum 4

#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) } • Pasaje de parámetros 5 puntos• Impresión correcta 5 puntos • Trazado función 10 puntos



62

PCR32.- Pregunta 3. Certamen Recuperativo, Segundo Semestre 2007, 20 ptos. Crear una función en C, que calcule lo siguiente:

∑= +

−n

i ii

1 )!1(*!*...4!*3!*2)12(*...*5*3*1

PCR33. Pregunta 2. Examen de Repetición, Segundo Semestre 2007, 15 ptos. Construir una función en C, dado N, que permita calcular lo siguiente:

....6!54!32!1 642 −+−+−

PCR34. Pregunta 1. Segundo Certamen, Segundo Semestre 2007, 25 ptos. Construya una función en C que permita CALCULAR y RETORNAR el resultado de la siguiente serie numérica:

∑=

−=

n

i iiS

1 4**12*8*4)12(**9*7*5*3*1

L

L



63

PCR35.- Pregunta 3. Segundo Certamen, Primer Semestre 2006, 25 ptos. Construya un programa que permita calcular la sumatoria de la siguiente función evaluada en el intervalo [a,b] de tipo entero, ingresado desde teclado. b Σ F(X)

i = a X3 – 5x Si x >5 X – 5 F(X) X2 + 3x Si 1 < x <= 5 X – 1 -(x2 + 10x) Si x <= 1 25

PCR36.- Pregunta 3. Examen de Repetición, Primer Semestre 2006, 35 ptos. Construir un programa en C que permita evaluar la siguiente sumatoria

∑=

+

+

n

i

i

ii

0

2

)!1(

Este programa debe incorpora el uso de funciones creadas por Usted (no se permite el uso de funciones existentes en las librerías del C).

A continuación se lista algunas preguntas que se encuentran en certamenes anteriores, estás preguntas las deben de resolver los alumnos. PCP37.- Pregunta 3. Segundo Test, Segundo Semestre 2007, 25 ptos. Construir una función en C que permita DEVOLVER la suma de los primeros K términos de la serie:

...6543

2 +−+−+=xxxxS

El valor de x y de K deberán ser entregados como argumentos a la función.



64

PCP38.- Pregunta 4. Segundo Test, Segundo Semestre 2007, 15 ptos. ¿Qué imprime en la salida estándar? 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; }



65

PARTE 4: ARREGLOS UNIDIMENSIONALES

Un arreglo es un conjunto de datos del mismo tipo que se puede representar de la siguiente manera:

5 6 7 8 7 4 8 0 0 1 2 3 4 5 6 7

Datos Indice Dicho arreglo podría haber sido representado por una definición de 8 variables de tipo char. Cabe destacar además 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: Declaración y lectura de un arreglo int a[10] //nombre del arreglo y dimensión) { a[4]=10; // en la posición 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.

INICIALIZACIÓN 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 { }



66

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 número 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(); }



67

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 O STRINGS Los strings o cadenas son arreglos unidimensionales de tipo char. Por convención, un string en C se termina con el carácter 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 tamaño 4, donde el último elemento es el carácter 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()



68

{ 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 función gets, la cual permite capturar toda la cadena desde teclado colocando el ‘/0’ al final de la cadena. Esto permite manejar de manera más simple el ingreso de cadenas a diferencia del scanf. Note además que basta con colocar el nombre de la cadena entre los paréntesis 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 también 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 ++;



69

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. Declaración de una matriz: int arreglo[filas][columnas];

int a[5][5],m[10][4],i,j,f,c // nombre del arreglo y dimensión Ejemplo: int arreglo[5][3]; Su representación es:

columna 1 columna 2 columna 3 0 1 2 Fila 1 0 Fila 2 1 Fila 3 2 Fila 4 3 Fila 5 4



70

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 través del nombre y su ubicación 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 mínimo 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 más importantes de las matrices está la posibilidad de resolver

sistemas de ecuaciones con n variables.



71

Las matrices cuadradas tienen algunas caracteristicas importantes asociadas a la ubicación de sus elementos en el conjunto. Se puede hablar de diagonal principal, diagonal secundaria, triangular superior, triangular inferior, por mencionar algunas.

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++) {

afc

6x6

Diagonal Principal f = c Diagonal Secundaria f+c = Dim - 1

TriangularSuperior

f < c

Triangular inferior f > c



72

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 función que calcule el largo de una cadena. 2.- Crear una función que cuente la coincidencia de 1 carácter dentro de un arreglo. 3.- Crear una función que cuente cuántas vocales se encuentran dentro de un arreglo. 4.- Crear una función que concatene dos cadenas. 5.- Crear una función que invierta una cadena. 6.- Crear una función que copie de una cadena a otra. 7.- Crear una función que copie de una cadena a otra a partir del i-ésimo elemento. 8.- Crear una función que compare dos arreglos y si son iguales retorne 1, en caso contrario que retorne 0. 9.- Crear una función que verifique si una matriz es diagonal (10x10). 10.- Crear una función que calcule:

A B C J AJ BK CL

D E F Ψ K = DJ EK FL

G H I L GJ HK IL

Las matrices son positivas. 11.- Crear una función que verifique si una matriz es positiva. 12.-Crear una función que realice el producto escalar de dos vectores 13.- Crear una función que verifique si una matriz es una matriz superior. 14.-Crear una función que verifique si una vector de (1x3), está contenido en una matriz de (3x3) de enteros.- 15.-Crear una función que sea capaz de intercambiar 2 filas ó dos columnas de una matriz de 4x4.- 16.- Crear una función que analice sintaticamente si un arreglo contiene los sigiuientes valores ASCII:

0-9 , ( , ) , + , - , * , / .



73

17.- Crear una función que analice semánticamente si se puede realizar una operación matemática con los siguientes caracteres :

0-9 , ( , ) , + , - , * , /



74


2008, REFERENTES AL MANEJO DE ARREGLOS, CADENAS Y

MATRICES A continuación se lista algunas preguntas que se encuentran en certamenes anteriores, estás preguntas están 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]; }



75

PCR42.- Pregunta 1. Examen de Repetición, 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 más de la mitad de las veces del total de elementos del arreglo (mayor a n/2). Asuma que el vector V de dimensión n ya está ingresado. Ejemplos:

V 1 2 0 2 2 2 Se debe imprimir el 1 y el 0 V 1 3 8 3 5 4 3 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 encriptación para codificar mensajes con el objeto de que el enemigo no supiera que contenían dichos mensajes. Los profesores de introducción a la programación han creado su propio algoritmo, con el objeto de que información clasificada (como los certámenes) no caigan en manos indebidas. Sin embargo, necesitan que sus alumnos le ayuden con la programación 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 convención sirve para llenar la matriz de 5x5 que constituyen la clave de encriptación. Por ejemplo: Si la frase secreta es "INTRODUCCION A LA PROGRAMACION"

La encriptación se realiza de la siguiente forma:

Para cada letra del mensaje original se busca la letra y se

cambia por el elemento contiguo (lado derecho del

carácter, si es el carácter final de una fila el primero de la

fila subsiguiente).Si la letra no está en la matriz, se deja el

mismo carácter, se aplica lo mismo cuando se trata del

último elemento de la última fila. Ejemplo: Supongamos que queremos codificar CERTAMEN, entonces el texto encriptado sería: AEORLMET Para lograr esto se le pide que construya un programa que utilice funciones (creadas por ud.) que realice la encriptación de una palabra ingresada por teclado.

I N T R O

D U C A L

P G M



76

PCR44.- Pregunta 2. Examen, Primer Semestre 2007, 30 ptos. Crear un programa utilizando funciones, el cual reciba un arreglo de n elementos de tipo entero, y un número entero. Posteriormente realiza una búsqueda 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 número. Ejemplo:

5 12 4 1 Si se ingresa 6 debe imprimir 5 y 1 Si se ingresa 7 se debe imprimir no existen elementos PCR45.- Pregunta 3. Examen, Primer Semestre 2007, 35 ptos.

Para el registro de notas finales de un curso se cuenta con el vector NOTAS de dimensión 40 de tipo entero y una matriz NOMBRE de 40x20 de tipo char ordenada alfabéticamente (ninguna sección 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 posición 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”. PCR46.- Pregunta 3. Examen, Primer Semestre 2007, 25 ptos. Dado un vector de dimensión n de tipo entero, leído desde teclado, construir un programa o función que permita determinar la existencia de un elemento mayoritario. En caso de existir se debe imprimir (o retornar en caso de función) dicho valor. Se dice que un elemento es mayoritario si se encuentra repetido más 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 dimensión 20 de tipo char, construir un programa que permita determinar si un vector de dimensión 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 leídos desde teclado. PCR48.- Pregunta 2. Segundo Certamen, Segundo Semestre 2007, 25 ptos. 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 función



77

que deje los puntos <=r en una matriz llamada R (máximo Nx2). Puede utilizar la función sqrt() de la librería math.h para calcular la raíz. Dados dos vectores, v= (v1,v2,…,vn) y w=(w1,w2,…, wn), la distancia euclidiana queda definida como:

22

222

11 )(...)()( nn vwvwvw −++−+−

PCR49.- Pregunta 3. Segundo Certamen, Segundo Semestre 2007, 30 ptos. Dados los siguientes arreglos, cuenta_corriente (tamaño Nx5) y depósitos (tamaño Mx11) tal que M>=N, crear una función que muestre el estado de la cuenta para un mes en particular. La nomeclatura para el arreglo cuenta_conrriente es el siguiente:

1 2 3 - A4 5 6 - B7 8 9 - C

Este arreglo no tiene elementos repetidos (no existen códigos de cuentas repetidas, cada fila corresponde a una cuenta). La nomeclatura para el arreglo depósitos es la siguiente:

0 1 2 3 4 5 6 7 8 9 10 1 2 3 - A 1 0 1 2 0 0 4 5 6 - B 1 1 2 0 0 0 1 2 3 - A 2 1 1 0 0 0 7 8 9 - C 2 0 0 1 0 0

La columna con índice 0 al 4 corresponde al código 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 función que dado un código busque en la matriz depósitos el total de depósitos. Por ejemplo, para 123-A, debería de mostrar 12.000. Puede utilizar la función llamada atoi() que transforma un arreglo a enteros. También puede utilizar la función strcmp. A continuación se lista algunas preguntas que se encuentran en certamenes anteriores, estás 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 (tamaño K) y otra con una frase donde se encuentra la palabra a reemplazar (tamaño N) donde N>K, crear una función que reemplace la palabra en el texto. El texto final puede quedar en una cadena llamada TextoFinal (de tamaño M) donde M>=N+K. Por ejemplo: La cadena reemplazar es: adiós despedida La cadena frase: El dio un adiós a quienes más quería



78

La cadena TextoFinal es: El dio un despedida a quienes más quería Note que sólo existe un espacio entre la palabra a buscar y el texto a reemplazar en la cadena reemplazar. Se pide crear una función 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, sólo 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 función atoi, la cual transforma una cadena a enteros. Ejemplo: 1 1 - 1 0 5 0 0 6 0 2 2 - 2 0 6 0 0 6 0 3 3 - 3 0 4 9 1 0 0 Finalmente la cadena Notas debería de quedar: 1 1 - 1 0 5 0 0 6 0 0 5 5 2 2 - 2 0 6 0 0 6 0 0 6 0 3 3 - 3 0 4 9 1 0 0 0 7 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 iteración, para un valor inicial de N=3 (15 puntos el ejercicio completo).

3- ¿Cuál es la expresión 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;



79

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 están ingresados. Además 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 5 4 1 Arreglo 2 1 2 3 4 5 6 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 1 1 1 1 0 0 1 1 1 0 0 0 1 1 0 0 0 0 1 0 0 0 0 0



80

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) e) pos 0 = 12 pos 1 = 20 pos 2 = 25 pos 3 = 30 pos 4 = 40

pos 0 = 12 pos 1 = 20 pos 2 = 25 pos 3 = 40 pos 4 = 30



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 máximo de String de 100, pero cuando haga el intercalamiento, debe recorrer sólo aquellas posiciones que contengan caracteres válidos (en el caso del String “Hola”, debe recorrer sólo los primeros 4 caracteres).



81

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 números enteros leídos desde teclado, luego deberá imprimir en la salida cuántas veces se encuentra el vector en la matriz por fila y por columna, en el mismo orden. Por ejemplo, sea la matriz:

1 1 1 1 12 1 2 1 13 3 2 1 11 1 1 1 12 2 1 2 1

Y el vector: 1 1 1 1 1

Su programa debería escribir 3 veces PCP49.- Pregunta 4. Examen, Primer Semestre 2006, 35 ptos. Todo libro editado tiene un número identificador que consta de diez cifras. A dicho número se le denomina ISBN (del inglés International Standard Book Number) y suele aparecer en las primeras páginas junto a otros detalles de la edición. 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 dígitos, es decir, valores entre 0 y 9. La segunda parte es el dígito de control, que en realidad puede ser un dígito o la letra X. Si se llama Xi al dígito que aparece en la posición i-ésima, la décima cifra viene dada por la siguiente ecuación:

⎟⎠

⎞⎜⎝

⎛= ∑

=

9

110 *

iiXiX mod 11

Al dividir por 11 se obtiene un resto entre 0 y 10; si es 10 se pone como dígito de control la letra X, de lo contrario el dígito de control viene dado por el valor obtenido de la ecuación. Se pide construir un programa en C que permita leer un número ISBN y permita determinar si es un número ISBN correcto o no. NOTA. Para decidir si un número ISBN es correcto o no se compara el dígito de control ingresado con el que se obtiene con la ecuación anterior.

- Asuma que en la primera parte del ISBN (los primeros nueve caracteres), siempre son caracteres numéricos.

- Por ejemplo:

‘2’ ‘3’ ‘7’ ‘6’ ‘5’ ‘4’ ‘1’ ‘2’ ‘3’ ‘-‘ ‘X’



82

PCP49.1.- Pregunta 2. Examen Repetición, 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 característica: 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. Además 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 1 4 3 6 14 2 4 1 2 9 5 0 2 3 10

M[5][5]

20 0 18 144 53

Su programa debe determinar si al ingresar por teclado cualquier matriz de n x n cumple con estas características.

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 información 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: Definición de una estructura para almacenar datos básicos 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. Obsérvese que la definición termina con un ; . Esto es debido a que la definición de una estructura es una sentencia. Note que los campos dentro de una estructura no requieren ser del mismo tipo de dato. El número de estructuras y el número de campos dependerá del problema a resolver, Hasta este punto no se han declarado variables, sólo se han definido las formas de los datos.



83

DECLARACIÓN DE VARIABLES DE TIPO ESTRUCTURA Sintaxis: struct nombre_estructura var1,var2,.... ,varN; o struct nombre_estructura{ Elementos de estructura }var1,var2,....,varN; Ejemplo 5.2: Definición 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);



84

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



85

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 número 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 PARÁMETROS DE UNA FUNCIÓN 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); }



86

EJERCICIOS PARTE 5: ESTRUCTURAS 1.- Crear una función que maneje los complejos y una función que asigne valores a las variables reales e imaginarias. 2.- Crear una función que realice la suma de complejos y retorne el resultado. 3.-Crear una función que realice la multiplicación complejos y retorne el resultado. 4.- Definido lo siguiente.

struct Facultad FAC[15]; trabajo TRAB[15]; calidad CAL[15]; Personal PER[300];

Además suponga que dichas estructuras ya poseen información. Crear una función que muestre a las personas que trabajan en la facultad de ingeniería.

5.- Crear una función que cuente la cantidad de personas de una determinada facultad. 6.- Crear una función que muestre a las personas de acuerdo a un determinado trabajo y a una determinada facultad. 7.-Transformar las siguientes tablas a estructuras. FACULTADES TRABAJO CodCarreraF Descripcion CodTrabajo Descripción FI Facultad de Ingeniería Decano Decano FMF Facultad de Mat. y Fisica Encargado Encargado de un bien FA Facultad de

Administración DocenteC Docente de Cátedra

FC Facultad de Ciencias DocenteA Docente Ayudante FM Facultad de Medicina Director Director de Depto. Secretaria Secretaria Auxiliar Auxiliar PERSONAL CodCarreraF Rut Nombre CodTrabajo CodCalidad Sueldo FI 1111-1 Juan Pérez DocenteC Docente 48 FI 1112-1 Daniel Molina DocenteC Docente 45 FI 1113-1 Marcelo

Cáceres Director Directivo 56

FMF 1114-1 Ivan Oyarzo Auxiliar Auxiliar 28 ... ... ... ... ... ... CALIDAD CodCalidad Descripción Directivo Director de Departamento ó

Escuela Docente Profesor Secretario Secretaria Auxiliar Auxiliar



87

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 función que ingrese las notas para un ramo determinado. 8.2) Crear una función que calcule el promedio para un determinado ramo 8.3) Crear una función 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];



88

char nombre[20]; char Direccion[30]; int telefono; char cod_curso[3]; }ALUMNOS[100]; /* Alumnos del colegio*/ 9.1) Crear una función que ingrese los datos personales del alumno 9.2) Crear una función que muestre a los alumnos( Nombre) de un determinado curso. 9.3) Crear una función que muestre los ramos de un determinado curso 9.4) Crear una función que permita ingresar las notas de un determinado curso y ramo. 9.5) Crear una función que permita modificar una nota de un determinado alumno de un curso

y ramo dados. 9.6) Crear una función que calcule los promedio de un determinado ramo y curso 9.7) Crear una función que muestre a los alumnos con un promedio determinado de un ramo y

curso dado.



89

PARTE 6: PUNTEROS Un puntero es una variable que hace referencia a una dirección de memoria Sintaxis: Tipo_Dato *nombre_variable_puntero; Ejemplo: int *p; Asignación de Dirección nombre_puntero=&variable; El carácter & delante de una variable indica que lo se está accediendo es a la dirección de memoria de dicha variable. Ejemplo: int *p; p=0; /* p posee la dirección NULL ó 0*/ p=NULL; /* p posee la dirección NULL ó 0*/ p=&i; /*p apunta hacia i ó conteniendo la dirección 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;

Inicialización Sintaxis: tipo_dato *nombre_puntero=&variable; Ejemplo: int i=7,*p=&i;



90

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; Expresión Expresión equivalente Valor P==&i P==(&i) 1 **&p *(*(&p)) 3 R=&x R=(&r) //ilicito 3*-*p/*q+7 ((3*(-(*p))))/(*q))+7 6 3*-*p/*q+7 //ilicito //ilicito (r=&k)=*p**q (*(r=&k))=((*p)*(*q)) 15 Llamada por valor Máx(a,b) Int a,b; { return((a>b)?a:b); } Llamado por referencia Máx(a,b,m_ptr) Int a, b,*m_ptr; { *m_ptr=(a>b)?a:b; } 3- Relación entre punteros y arreglos.



91

Un puntero es una variable cuyos valores son direcciones. El nombre de un arreglo es una dirección o puntero fijo. Cuando se declara un arreglo, el compilador debe asignar una dirección 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 aritmética de puntero proporciona una opción para la indización de arreglos, las proposiciones p=a+1; = 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; Son ilícitas, no se puede cambiar la dirección de a. Expresiones apuntadoras como p+1, ++p y p+=i son válidas. Double a[ ]; = double*a;



92

Cadenas Las cadenas son arreglos unidimensionales de tipo char, Por convención, una cadena en C se termina con centinela de fin de cadena ó carácter 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 función, en el encabezamiento, la declaración: Int (*v)[5]; = int v[ ][5]; Int c[7][9][2]; C[i][j][k] = (&c[0][0][0]+9*2+i+2*j+k) Ejercicios de punteros 1.- ¿ Cuál es el valor de *p y *(p+2) en cada caso? a) int *p

papa[4]={12,21,121,212}; p=papa;

*p 12 *(p+2) 121



93

b) char *ptero;

char arreglo[7]={'C','L','A','U','D','I','O'}; ptero=arreglo;

*ptero 'C' *(ptero+2) 'A'

c) int *ptero;

int arreglo[2][2]={{1,2},{3,4}};

*ptero 1 *(ptero+2) 3 d) int *ptero;

static int arreglo [4]={1023,7};

*ptero 1023 *(ptero+2) 0 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 15 arreglo[2] 5 b) i=10, ptero=arreglo

i=(*p)+1+(*ptero)+2 ptero=*ptero+3+i

i 14 arreglo[0] 18



94

USO DE TYPEDEF C proporciona diversos tipos fundamentales, como char e int, y varios tipos derivados, como arreglos y punteros; también proporciona la declaración typedef, que permite la asociación explícita 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 después 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 declaración de un tipo sinónimo de int.

Referencia Bibliografica:

Introducción a la Programacion en C, Kelley/Pohl



95

SOLUCIONES A EJERCICIOS PLANTEADOS Ejercicios resueltos parte 1: Estructuras e Instrucciones básicas 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 solución, es que la primera no puede efectuar una multiplicación entre decimales.

2. #include<stdio.h> #define PI 3.1415 main() { float radio; printf(“Ingrse el radio \n”); scanf(“%f”,&radio); printf(“El perímetro es %f \n”, PI * radio* 2.0);

getchar(); }

3. #include<stdio.h> main() { float a,b; printf(“Ingrese el largo del rectángulo \n”); scanf(“%f”,&a);



96

printf(“Ingrese el ancho del rectángulo \n”); scanf(“%f”,&b); printf(“El perímetro del rectángulo es %f \n”, 2*a + 2*b); printf(“El área del rectángulo 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



97

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()



98

{ 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() {



99

int N, i,mayor;

printf("Ingrese un valor \n"); scanf("%d",&N);

mayor=N; i=1; while(i<=STOP) {


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;


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(); }



100

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 después del while(i) , viene el termino de la sentencia ; es decir el programa jamás alcanza la sentencia i--, por ello la expresión i , siempre es verdadera. 10. Este también es un ciclo infinito, ya que siempre está ejecutando la sentencia printf(“ El valor de i es : %d\n",i); , por lo que nunca alcanza el incremento i++;



101

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;



102

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"); }



103

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 operación es : %f \n",res); } else printf("Los valores ingresados no permiten realizar la operación \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");



104

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 operación es : %f \n",x/fact); } else printf("Los valores ingresados no permiten realizar la operación \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 operación es : %f \n",res); } else printf("Los valores ingresados no permiten realizar la operación \n"); }



105

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 operación es %f \n",suma); } else printf("El valor ingresado no permite realizar la operación \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); }



106

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 números, muestre el mayor, menor, y cuantos de ellos son múltiplos 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;



107

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); } Solución de Certamenes de años anteriores Solución 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)

Solución PCR24:

N 6

i 1 2 3 4 5 6 7

cont 0 1

stop 1

SALIDA 1 0 0 0 0 0

Solución 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



108

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”) } }

5 pts

2 3 1 2 3 4 10 pts

16

5 pts

1 3 0 1 3 6 10 pts

Ejercicios resueltos parte 3: Funciones Solución de Certamenes de años anteriores Solución PCR31:

main() funcionX j Monitor x i sum 4 4 1 1 5 2 3 6 6 3 7 4 8 5 1 1 2 3 4 5 6 1 1 2 3 3 6 4 5 6 7 1 1 2 3

#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 ( )

4



109

5 6 7 8 1 1 2 3 3 4 7 5 6 7 8 9 1 1 2 3 4 4 5 6 7 8 9

Solución 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 } Solución PCR33:



110

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 } Solución 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 } Solución PCR35: #include<stdio.h>



111

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)); } Solución 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)



112

{ 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[ ])



113

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



114

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 sería:

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])



115

{ 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++)



116

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[ ]) {



117

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++)



118

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);



119

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);



120

} Solución de Certamenes de años anteriores Solución PCR41: Retorna la vocal que más se repite Solución 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++)



121

if(vector[i]!=mayoritario) printf(“ %d”, vector[i]); else continue; } Solución 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; } }



122

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'; } Solución 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 número a analizar :"); scanf("%d",&x); if (buscar(x)) printf(" Si existen "); else printf(" NO existen"); getchar(); getchar(); }



123

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

Solución 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(); } Solución PCR46: #include<stdio.h> int vector[1000],n,i,j,mayoritario,ctamayoritario,ctapaso; main() { do {



124

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; } Solución 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);



125

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 búsqueda por fila // Búsqueda 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 búsqueda por columna return (0); // no está } int ObtenerLargo(char patron[])



126

{ 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); } Solución 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



127

R[k][1]=Punto[i][1]; // 2 k++; } else continue; } Solución 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



128

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



129

}

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];



130

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



131

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 introducción a la programación .pdf (claudio gutiérrez-soto)

Documents