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
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
Página : 2
Claudio Gutiérrez-Soto, Manuel Crisosto,
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.
Página : 3
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
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
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
Página : 4
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.
Página : 5
Algoritmo EC 1er Grado

Programa que
Variables
permite
a,b,x de tipo entero
resolver la
Inicio
ecuación de
Escribir(“Ingrese valores de EC”)
primer grado
Leer (a,b)
Si a = 0 entonces #include <stdio.h>
escribir (“Error”) int a,b,x;
sino main()
Inicio {
x=-b/a printf(“Ingrese valores de EC”);
Escribir (“La solución es:”,x) scanf(“%d %d”,&a,&b);
Fin if a ==0 printf (“error”);
ax+b=0 Escribir(“Fin programa”) else
Fin {
x = -b / a;
a ? printf(“La solución es %d:”,x);
}
x= -b / a printf(“Fin programa”);
b }
a≠0
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:
Página : 6
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.
Página : 7
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.

Algoritmo para multiplicar tres números:
Datos de Entrada: tres • Definimos cuatro variables var1, var2, var3 y var4
números (x1,x2,x3) de tipo entero
• Pedimos el primer valor
Información de Salida: • Almacenamos ese valor en var1.
Suma de x1,x2 y x3 • Pedimos el segundo valor
• Almacenamos ese valor en var2.
Restricciones: Ninguna • 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.
Página : 8
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.
DIAGRAMA DE FLUJO NOMENCLATURA PSEUDO-CÓDIGO
Inicio Inicio de Algoritmo Inicio
Variables
Entero var1, x , y Definición de variables Entero var1, x, y
Real a, b Real a, b
Escribir Impresión de mensajes

“Mensaje 1” Escribir (“Mensaje 1”)
Leer
var1,x, y Lectura de mensajes Leer (var1, x, y)
Transformación de datos
a=3*x+ y Operaciones sobre los datos a=3*x+ y
b = a / var1 b = a / var1
Si a > b Entonces
F V Bifurcación en la ejecución Inicio
Si a > b Instrucciones…
de instrucciones
Fin
Sino
Inicio
Conector Instrucciones…
Fin
Fin Fin de algoritmo Fin
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.
Página : 9
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
Inicio En pseudos-código:
Algoritmo Suma
Variables
int var1,var2 ,var3 Entero var1, var2, var3
Inicio
Escribir(“Ingrese el primer valor”)
Leer (var1)
Ingrese el primer valor
Escribir(“Ingrese el segundo valor”)
Leer (var2)
var3=var1+var2
Escribir(“El resultado es:”,var3)
var 1 Fin
Ingrese el segundo valor

El lenguaje C:
var 2 #include<stdio.h>
int var1,var2,var3;
main()
{
var3=var1+var2 printf(“Ingrese el primer valor:”);
scanf(“%d”,&var1);
printf(“Ingrese el segundo valor:”);
scanf(“%d”,&var2);
var3=var1+var2;
El resultado es : var3
printf(“El resultado es:%d”,var3);
}
Termino
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.
Página : 10
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).
En pseudos-código:
Algoritmo Edad
Inicio Variables
Entero edad
Inicio
Escribir(“Ingrese su edad:”)
Entero Edad Leer (edad)
Si (edad >= 18) Entonces
Inicio
Escribir(“Usted es mayor de edad”)
Ingrese su edad Fin
Sino
Inicio
Escribir(“Usted es menor de edad”)
Edad Fin
Fin
El lenguaje C:
v #include<stdio.h>
Edad >= 18 Usted es mayor int edad;
de edad main()
{
f printf(“Ingresesu edad:”);
scanf(“%d”,&edad);
Usted es
if (edad >= 18)
menor
{
de edad
printf(“Usted es mayor de edad”);
}
else
Termino {
printf(“Usted es menor de edad”);
}
}
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.
Página : 11
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.
Página : 12
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.
Instrucción a
Instrucción a
expresión F mientras (expresión)

Inicio
Instrucción 1
V
Instrucción 2
Instrucción 1
Instrucción 2
Instrucción N Instrucción n
Fin
Instrucción b Instrucción b
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.
Página : 13
Instrucción a
Instrucción a
do
Instrucción 1 Inicio
Instrucción 1
Instrucción 2
Instrucción 2
Instrucción N
Instrucción n
V Fin
expresión mientras (expresión)
F
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.
Página : 14
Instrucción a
Instrucción a
Vc = Vi , Vf /
Condición, Salto Para ( Vc=Vi; Vf / Condición; Salto)
Inicio
Instrucción 1
Instrucción 1 Instrucción 2
Instrucción 2
Instrucción N
Instrucción n
Fin
Ciclo Para (variables de control)
A continuación de verán algunos ejemplos para clarificar estas estructuras.
Ejemplo: Construir la tabla de multiplicar de un numero ingresado por teclado,

partiendo desde cero.
Entrada: x
Salida: x*0, x*1, x*2, x*3………..x*x
Restricciones: No tiene
Inicio Algoritmo Tabla de Multiplicar

Variables
Entero a,b
Entero a,b Inicio
Escribir (“Ingrese un número entero:”)
Leer (a)
Escribir b=0
“Ingrese un numero entero:” Para (b=0; b<a; salto 1)
Inicio
Escribir (a,b,a*b)
Leer (a)
Fin
Fin
b←0
#include <stdio.h>
Int a, b;
b=0,b<a, inc 1 main()
{
printf(“Ingrese un número entero:”);
scanf(“%d”,&a);
Escribir
a, b, a*b
for(b=0;b<a;b=b+1)
{
printf(“%d * %d = %d,a,b,a*b);
}
}
Página : 15
Fin Claudio Gutiérrez-Soto, Manuel Crisosto,
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
Página : 16
Inicio Inicio
Entero a,b,x Entero a,b,x

Real fx Real fx
Escribir Escribir
“Ingrese los valores de a y b” “Ingrese los valores de ay b”
Leer (a,b) Leer (a,b)
F V V Si a > b
Si a < b
F
Escribir
“a debe ser menor que b” x=a,x<=b, inc 1
x=a,x<=b, inc 1
fx = (3*x*x+5*x-2) / 125
fx = (3*x*x+5*x-2) / 125
Escribir
x, fx Escribir
x, fx
Fin
Fin
La primera 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.
Página : 17
Uso de bifurcación y ciclo para Uso de repetir… mientras y ciclo para

Algoritmo F(x) Algoritmo F(x)
Variables Variables
Entero a,b,x Entero a,b,x
Real fx Real fx
Inicio Inicio
Escribir(“Ingrese los valores de a y b”) Escribir(“Ingrese los valores de a y b”)
Leer (a,b) Repetir
Si (a<b) entonces Inicio
Inicio Leer (a,b)
Para (x=a, x<=b, inc 1) Fin
Inicio Mientras (a > b)
fx = (3*x*x+5*x-2) / 125 Para (x=a, x<=b, inc 1)
Escribir ( x, fx) Inicio
Fin fx = (3*x*x+5*x-2) / 125
Fin Escribir ( x, fx)
Si no Fin
Inicio Fin
Escibir(“a debe ser menor que b”)
Fin
Fin
Equivalente en lenguaje C
#include<stdio.h> #include<stdio.h>
int a,b,x; int a,b,x;
flota fx; flota fx;
main() main()
{ {
printf(“Ingrese los valores de a y b”); printf(“Ingrese los valores de a y b”);
scanf(“%d”,&a); do
scanf(“%d”,&b); {
if (a<b) scanf(“%d”,&a);
{ scanf(“%d”,&b);
for (x=a;x<=b;x=x+1) }
{ while (a>b)
fx= (3*x*x+5*x-2) / 125; for (x=a;x<=b;x=x+1)
printf(“%d %f”, x,fx); {
} fx= (3*x*x+5*x-2) / 125;
} printf(“%d %f”, x,fx);
else }
{ }
printf(“a debe ser menor que b”)
}
}
Página : 18
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.
Página : 19
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
En pantalla :
#include<stdio.h> Hola mundo.
main()
{
printf(“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.
Página : 20
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() Se imprimirá lo siguiente en pantalla:
{
int entero=1; // declaración de una variable entera El valor del entero es : 1
// llamada entero, con valor 1. El valor del flotante es : 1.56356789;
float comaflotante =1.56356789; El valor del carácter es : a
char caracter=’a’; Esta es una cadena
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);
Página : 21
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> Se imprimirá lo siguiente en pantalla :
main()
{ El valor de i es : 56.111111
float i=56.111111111; El valor de i es : 56.111111
printf(“El valor de i es : %f \n”,i); El valor de i es : 56.111111
printf(“El valor de i es : %5f \n”,i); El valor de i es : 56.1
printf(“El valor de i es : %15f \n”,i); El valor de i es : 56.11111
printf(“El valor de i es : %.1f \n”,i); El valor de i es : 56
printf(“El valor de i es : %.5f \n”,i); El valor de i es : 5.61111e+01
printf(“El valor de i es : %.0f \n”,i);
printf(“El valor de i es : %e \n”,i);
getchar();
}
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”
***
*** *** ***
***
Página : 22
Entre otras características del printf( ), podemos encontrar.
Ejemplo 1.6: Aquí se muestra que es posible realizar las Esto imprimirá :
operaciones matemáticas básicas dentro del printf.
#include<stdio.h> La suma de la variable a+b es : 7.
main()
{
int a, b;
a=3; b=4;
printf(“La suma de la variable a+b es : %d. \n”, a+b);
}
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);
}
Página : 23
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: --
Página : 24
Ejemplo 1.10 Aquí se muestra la aplicación del

incremento y decremento de variables
#include<stdio.h>
main()
{ Esto imprimirá :
int i=0, j=1;
i++; El valor de i es : 1
j--; El valor de j es : 0
printf(“El valor de i es : %d. \n”,i);
printf(“El valor de j es : %d. \n”,j);
getchar();
}
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() Imprimirá en pantalla lo siguiente:
{
int i=2,j=2,a,b; El valor de a es : -4 y el de i es: 3
a=-2*i++; El valor de b es : -6 y el de j es: 3
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();
}
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.
Página : 25
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.
Página : 26
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();
}
Página : 27
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;
scanf(“%f”,&a);
scanf(“%f”,&b);
if(b!=0)
printf(“El resultado es %f \n”,a/b);
else
print(“El resultado no existe \n”);
Página : 28
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
#include<stdio.h>
main()
{
int numero;
printf(“Ingrese un número \n”);
scanf(“%d”,&numero);
if(!(numero%2))
Página : 29
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
#include<stdio.h>
main()
{
int a,b,c;
scanf(“%d”, &a);
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
}
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
#include<stdio.h>
main()
{
int a,b,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
getchar();
Página : 30
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
#include<stdio.h>
main()
{
int a,b,c,min,max;
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);
}
Página : 31
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
#include<stdio.h>
main()
{
int a,b,c,min,max;
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);
}
Página : 32
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”);
Página : 33
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.
Página : 34
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
#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.
Página : 35
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).

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;
scanf("%d",&a);
printf(" Ingrese b \n";
scanf("%d",&b);
printf("Ingrese 1 suma, 2 resta, 3 división ó 4 multiplicación \n");
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");
}
Página : 36
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”);
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();
}
Página : 37
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.
#include<stidio.h>
main()
{
float a,b,c,
char opcion;
int bandera=1;
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)
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
Página : 38
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 \”);
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 \”);
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();
Página : 39
}
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
#include<stdio.h>
main()
{
int contador,a,b,pot;
printf(“Ingrese la base\n”);
scanf(“%d”,&a);
printf(“Ingrese el exponente \n”);
scanf(“%d”,&b);
if(a>0 && b>0)
{
contador=1:
pot=1;
while(contador<=b)
{
pot=pot*a;
contador=contador+1;
}
printf(“El resultado de %d elevado a %d es %d \n”,a,b,pot);
}
else
printf(“Hay un 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).
Página : 40
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++;
}
Página : 41
PROPOSICIÓN FOR
Sintaxis:
for (expresión1 ; expresión2 ; expresión3)

proposición verdadera;
proposición siguiente;
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();
}
Página : 42
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”);
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
#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”);
}
Página : 43
Ejemplo 2.19: Cree un programa que calcule ab, donde a >0 y b>0
Entrada : a,b
Salida : ab
Restricciones: a>0 y b>0
#include<stdio.h>
main()
{
int i,a,b,pot;
printf(“Ingrese la base\n”);
scanf(“%d”,&a);
printf(“Ingrese el exponente \n”);
scanf(“%d”,&b);
if(a>0 && b>0)
{
for(i=pot=1; i<=b; i++)
pot=pot*a;
printf(“El resultado de %d elevado a %d es %d \n”,a,b,pot);
}
else
printf(“Hay un 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
#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”);
}
Página : 44
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!

n
3*∑ i 2*i-1/(n-i)!
i=1
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.
Página : 45
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.
#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") ;
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");
}
Página : 46
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”
}
}
Página : 47
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 N I J suma1 suma2
Imprimir(“Ingrese N”) 3
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”)
}
}

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 N i pot exp Imprime:

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
}
Página : 48
PCP 2.- Dado los siguientes algoritmos, obtenga los valores de las
variables que aparecen en la tabla en cada iteración.
a)
int i,j,suma=0,stop=1,N N i j stop suma

printf “Ingrese N” 4
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)
int i,j,k,N N i j k printf
printf “Ingrese N” 1
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
Página : 49
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.
Página : 50
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*/
Página : 51
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:
Página : 52
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
#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
#include<stdio.h>
int suma(int a,int b);
main()
{
int a,b,result;
scanf("%d",&a);
scanf("%d",&b);
result=suma(a,b);
Página : 53
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
#include<stdio.h>
void imprimir_valores(int suma);
main()
{
int a,b,result;
scanf("%d",&a);
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
#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");
printf("El número mayor es %d \n",mayor(valor1,valor2));
}
Página : 54
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
#include<stdio.h>
void mayor(int a,int b);
main()
{
int valor1,valor2;
printf("Ingrese un número \n");
printf("Ingrese un segundo valor \n");
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;
Página : 55
scanf("%f",&a);
printf("Ingrese b \n");
scanf("%f",&b);
printf("Ingrese 1 para sumar o,2 resta, 3 mutiplicación,4 division \n");
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)
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);
}
Página : 56
Ejemplo 3.7: Crear un programa que calcule ab , utilizando funciones.
Entrada: a,b
Salida: ab
#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);
Página : 57
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;
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)
{
Página : 58
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 suma(int c, int d) // c y d corresponden a

int f , a, b; /* variables globales*/ // los parámetros formales
int suma(int c,int d); /*prototipo*/ {
main() return (c+d);
{ }
scanf(“%d”,&b);
scanf(“%d”,&a);
f = suma(a,b ); // a y b corresponden a los
... // parámetros reales
}
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.
Página : 59
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 El módulo que llama envía la dirección de
variables locales y los valores de los memoria del parámetro real. Entonces una
parámetros reales se copian en los variable pasada como parámetro por referencia
correspondientes parámetros formales. puede ser modificada directamente por el
subprograma.
Los cambios que se produzcan en los
parámetros por efecto del subprograma En lenguaje C, cuando se realiza un paso de
(función) no afectan a los argumentos parámetro por referencia el argumento se
originales. precede del símbolo &.
Como ejemplo se pide comparar los siguientes códigos:
Por valor Por referencia

... ...
int a, b, c; int a, b, c;
a=5; b=6; c=20; a=5; b=6; c=20;
sumar(a,b,c); sumar(a,b,&c);
printf(“ el valor de c es %d”, c); printf(“ el valor de c es %d”, c);
... } ... }
void sumar(int x, y, z) void sumar(int x,y,* z)

{ {
z = x + y; *z = x + y;
} }
Página : 60

2008, REFERENTES AL MANEJO DE FUNCIONES

PCR31.- Pregunta 4. Segundo Certamen, Primer Semestre 2006, 20 ptos.
Realice el seguimiento del siguiente programa. Indique en la tabla los valores que toma cada
variable.
#include <stdio.h> main() funcionX

int n,j; j Monitor x i sum
int funcionX(int x);
4
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
Página : 61
PCR32.- Pregunta 3. Certamen Recuperativo, Segundo Semestre 2007, 20 ptos.
Crear una función en C, que calcule lo siguiente:
n
1 * 3 * 5 * ... * (2i − 1)
∑ 2!*3!*4!*...* (i + 1)!
i =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:
1!−2 2 + 3!−4 4 + 5!−6 6....
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
1 * 3 * 5 * 7 * 9 * L * (2i − 1)
S =∑
i =1 4 * 8 *12 * L * 4i
Página : 62
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+2
∑
i = 0 (i + 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).

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:
x x x x
S = 2+ − + − + ...
3 4 5 6
El valor de x y de K deberán ser entregados como argumentos a la función.
Página : 63
¿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;
}
Página : 64
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 { }
Página : 65
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();
}
Página : 66
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
#include<stdio.h>
main()
Página : 67
{
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 ‘ ‘)
#include<stdio.h>
main()
{
char nombre[20];
int i,largo;
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
#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 ++;
Página : 68
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)
#include<stdio.h>
main()
{
char nombre[20];
char aux[20];
int i,j,largo;
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
Página : 69
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.
Página : 70
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.
Diagonal Principal f=c Diagonal Secundaria f+c = Dim - 1
Triangular
afc Superior
f<c
6x6
Triangular inferior f>c
Ejemplo 4.9: Crear un programa donde se introduzca 2 matrices de 4x4 y que entregue el
resultado de la suma de ambas matrices:
Entrada: Ingreso de valores para dos matrices de 4X4

Salida: Muestra el resultado de la suma de ambas matrices
#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++)
{
Página : 71
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

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 , ( , ) , + , - , * , / .
Página : 72
17.- Crear una función que analice semánticamente si se puede realizar una operación matemática
con los siguientes caracteres :
0-9 , ( , ) , + , - , * , /
Página : 73

2008, REFERENTES AL MANEJO DE ARREGLOS, CADENAS Y
MATRICES

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];
}
Página : 74
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:

I N T R O
D U C A L
P G M 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.
Página : 75
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
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”.
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.
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.
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
Página : 76
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:
( w1 − v1 ) 2 + ( w2 − v 2 ) 2 + ... + ( wn − v n ) 2
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 - A
4 5 6 - B
7 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.

anteriores, estás preguntas las deben de resolver los alumnos.
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
Página : 77
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
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;
Página : 78
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
Página : 79
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 0 = 12 pos 0 = 30 pos 0 = 40 Ninguna de las
pos 1 = 20 pos 1 = 20 pos 1 = 40 pos 1 = 30 anteriores
pos 2 = 25 pos 2 = 25 pos 2 = 25 pos 2 = 25
pos 3 = 30 pos 3 = 40 pos 3 = 20 pos 3 = 20
pos 4 = 40 pos 4 = 30 pos 4 = 12 pos 4 = 12
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).
Página : 80
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 1
2 1 2 1 1
3 3 2 1 1
1 1 1 1 1
2 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 ⎞
X 10 = ⎜ ∑ i * X i ⎟ mod 11
⎝ i =1 ⎠
Al dividir por 11 se obtiene un resto entre 0 y 10; si es 10 se pone como 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’
Página : 81
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
M[5][5]
2 4 1 2 9
5 0 2 3 10
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.
Página : 82
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);
Página : 83
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);
}
Página : 84
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);
}
Página : 85
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 DocenteC Docente de Cátedra
Administración
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 Director Directivo 56
Cáceres
FMF 1114-1 Ivan Oyarzo Auxiliar Auxiliar 28
... ... ... ... ... ...
CALIDAD
CodCalidad Descripción
Directivo Director de Departamento ó
Escuela
Docente Profesor
Secretario Secretaria
Auxiliar Auxiliar
Página : 86
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];
Página : 87
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.
Página : 88
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;
Página : 89
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.
Página : 90
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;
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;
Página : 91
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
Página : 92
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
Página : 93
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
Página : 94
SOLUCIONES A EJERCICIOS PLANTEADOS
Ejercicios resueltos parte 1: Estructuras e Instrucciones básicas
1. #include<stdio.h>
main()
{
int a,b;
scanf(“%d”,&a);
scanf(“%d”,&b);
printf(“el resultado es : %d \n”, a*b);
}
#include<stdio.h>
main()
{
float a,b,mult;
scanf(“%f”,&a);
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.
#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();
}
main()
{
float a,b;
printf(“Ingrese el largo del rectángulo \n”);
scanf(“%f”,&a);
Página : 95
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);
}
main()
{
float a,b,c,d,suma,mult,pro;
scanf(“%f”,&a);
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);
}
void main()
{
float a,b,c,d,suma,mult,pro;
scanf(“%f”,&a);
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
Página : 96
7. No esta definida la variable suma

8.
Ejercicios resueltos parte 2: Estructuras de Control
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();
}
main()
{
int N, i, j, suma=0,pot;

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;
}
}
}
main()
Página : 97
int N, i, j, suma=0,fact;

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;
}
}
}
main()
{
int N, i, j, suma=0,pot=1;
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++;
}
}
}
#define STOP 15
main()
{
Página : 98
int N, i,mayor;
printf("Ingrese un valor \n");

scanf("%d",&N);
mayor=N;
i=1;
while(i<=STOP)
{

scanf("%d",&N);
if(mayor>N)
mayor=N;
i=i+1;
}
printf("El numero mayor es %d \n",mayor);
}
#define STOP 20
main()
{
int N, i,mayor,min;

scanf("%d",&N);
mayor=N;
min=N;
i=1;
while(i<=STOP)
{
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();
Página : 99
main()
{
int i;
float a,b,factA,factB_A;
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");
#define STOP 15
main()
{
int valor,contpares=0,i;
i=1;
while(i<=STOP)
{
printf(“ingrese un valor \n”);
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++;
Página :100
11. Calcular lo siguiente : 1+2+3+4+5+...+N
#include<stdio.h>
void main()
{
int suma,i,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;

scanf("%d",&N);
if(N>0)
{
for(i=1 ,suma=0; i<=N ; i++)
suma=suma+i*i;
}
}
13. Crear un programa que calcule: 10+21+32+43+...+NN-1
#include<stdio.h>
main()
{
int suma,i,j,pot=1,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;
Página :101
suma=suma+pot;
}
}
}
14. Crear un programa que calcule: 11+22+33+44+..+Nn
#include<stdio.h>
void main()
{
int suma,i,j,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;
}
}
}
15. Crear un programa que calcule lo siguiente: 1!+2!+3!+4!+...+N!
#include<stdio.h>
main()
{
int suma,i,j,N,fact;

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;
}
}
else printf("El valor ingresado no es un entero positivo \n");
}
Página :102
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");
}

(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");
Página :103
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);
}
}
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);
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);
}
}
Página :104

n
3*∑ i 2*i-1/(n-i)!
i=1
#include<stdio.h>
main()
{
int i,j;
float suma,fact,pot,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");
}

n i
∑ ∑ ( (2*i)/j )
i=1 j=1
#include<stdio.h>
main()
{
int i,j,N;
float res,suma=0.0;
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);
}
Página :105
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;
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;

scanf("%d",&valor);
mayor=menor=valor;
if(!(valor%5))
mult5++;
for(i=2; i<= STOP ; i++)

{
scanf("%d",&valor);
if(valor>mayor)
mayor=valor;
else if( valor< menor)
menor=valor;
Página :106
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 i cont stop SALIDA

6 1 0 1 1
2 1 0
3 0
4 0
5 0
6 0
7
Solución PCR25
int i,j,suma1,suma2 N I J suma1 suma2
Imprimir(“Ingrese N”) 3 1 1 0 0
Leer(N) 2 2 2 1
3 1 7 0
Página :107
if(N>0) 2 16 1
{ 3 3
suma1=0 5 pts 1 5 pts 0
for(i=1; i<=N ;i=i+1) 2 1
{ 3 3
suma2=0 4 6
j=1
while (j<=i) 10 10
{ pts pts
suma2=suma2+j
j=j+1
}
suma1=suma1+i+suma2
}
Imprimir(suma1)
}
else {
Imprimir(“Error”)
}
}
Ejercicios resueltos parte 3: Funciones
Solución PCR31:
#include <stdio.h> main() funcionX

int n,j; j Monitor x i sum
int funcionX(int x);
4 4 1 1
main() 5 2 3
{ 6 6 3
for (j=4;j<=9;j++) 7 4
{ 8 5 1 1
if (funcionX(j)==j)
2
printf ("\n %d Si es !!",j);
} 3
} 4
5
/* Funcion */ 6 1 1
int funcionX(int x)
2 3
{
int i, suma; 3 6
suma=0; 4
i=1; 5
while (i<x) 6
{
7 1 1
if ((x%i) = =0)
suma=suma+i; 2
i++; 3
}; 4
t ( )
Página :108
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:
Página :109
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>
Página :110
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)
Página :111
{
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[ ])
Página :112
{
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.-
Página :113
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])
Página :114
{
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++)
Página :115
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[ ])
{
Página :116
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++)
Página :117
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);
Página :118
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’)
{
return(seguir);
else
seguir=0;
}
else seguir=0;
}
else return(seguir);
}
else if(largo==1)
{
return(seguir);
else seguir=0;
}
else seguir=0;
return(seguir);
Página :119
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++)
Página :120
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;
}
}
Página :121
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();
}
Página :122
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 {
Página :123
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);
Página :124
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[])
Página :125
{
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
Página :126
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
Página :127
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;
}
Página :128
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];
Página :129
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++)
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(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;
}
Página :130
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 */
Página :131

Apunte de Introducción A La Programación .PDF (Claudio Gutiérrez-Soto)

Enviado por

Dados do documento

Título original

Direitos autorais

Formatos disponíveis

Compartilhar este documento

Compartilhar ou incorporar documento

Opções de compartilhamento

Você considera este documento útil?

Este conteúdo é inapropriado?

Direitos autorais:

Formatos disponíveis

Apunte de Introducción A La Programación .PDF (Claudio Gutiérrez-Soto)

Enviado por

Direitos autorais:

Formatos disponíveis

INTRODUCCIÓN A LA

Quiero agradecer de manera anticipada a los alumnos de introducción a la programación,

Estimados alumnos, el material que se presenta a continuación está diseñado para

Como ustedes pondrán ver el conjunto de símbolos, instrucciones y estructuras presentes

El objetivo general es resolver problemas básicos a través de la construcción de

La mayoría de los problemas que se resuelven en el transcurso de un curso de programación viene

Algoritmo EC 1er Grado

Tipo de dato Propósito

De lo anterior podemos decir que:

En los algoritmos y lenguajes de programación no se usan neuronas, pero podemos definir

Ejercicio 0.1: Cree un algoritmo que multiplique tres números.

Existen un conjunto de símbolos básicos utilizados en la constricción de diagramas de flujo, los

DIAGRAMA DE FLUJO NOMENCLATURA PSEUDO-CÓDIGO

Inicio Inicio de Algoritmo Inicio

Escribir Impresión de mensajes

Fin Fin de algoritmo Fin

Entrada: Dos números (x1 y x2)

Ingrese el segundo valor

En las bifurcaciones o estructura de control, se evalúan proposiciones utilizando:

(P1) (P2) (P1) and (P2) (P1) or (P2) Not (P1)

Ejemplo 0.4: Evaluación de una expresión compuesta

Asumamos la siguiente expresión:

Existen aplicaciones en las cuales se requiere repetir un número determinado de instrucciones, en

Un ciclo es la repetición de un conjunto de instrucciones. Dicho ciclo culmina cuando se cumple

CICLO MIENTRAS (EXPRESIÓN): Esta estructura se utiliza cuando se quiere repetir un

expresión F mientras (expresión)

CICLO REPETIR (INSTRUCCIONES) MIENTRAS

Ciclo Repetir …. Mientras

En las estructuras anteriores el número de veces que se repetirán las instrucciones no

CICLO PARA (VARIABLES DE CONTROL): En este ciclo el número de veces que se

Ciclo Para (variables de control)

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

Ejemplo: Construir la tabla de multiplicar de un numero ingresado por teclado,

Inicio Algoritmo Tabla de Multiplicar

En el ejemplo anterior, la variable de control b se inicializa en 0 (b=0) y el grupo de instrucciones

Algunas características del ciclo Para:

Entero a,b,x Entero a,b,x

Leer (a,b) Leer (a,b)

Uso de bifurcación y ciclo para Uso de repetir… mientras y ciclo para

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

4. Que resuelva la ecuación de primer grado y muestre el resultado

8. Que permita el ingreso de 15 números y que muestre el mayor, el menor y el promedio.

10. 12+22+32+… +N2

12. 11+22+33+… +NN

13. -11+22-33+…..+Nn, tal que N es par

PARTE 1: ESTRUCTURA E INSTRUCCIONES BÁSICAS EN EL LENGUAJE C

La siguiente es la estructura general de un programa en C

En este sencillo ejemplo, podemos visualizar lo siguiente:

#include<stdio.h> Esto hace referencia a la librería stdio.h, la cual posee

Una vez compilado, arrojará en pantalla:

Este es mi primer programa en C.

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

Ahora utilizaremos los caracteres de control

Ahora veremos como se utilizan la lista de argumentos del printf( ).

CARÁCTER TIPO DE DATO

Ejemplo 1.5: En este ejemplo se muestran los caracteres de

Esto imprimirá lo siguiente :

Estos han sido unos ”EXCELENTES EJEMPLOS”

Entre otras características del printf( ), podemos encontrar.

El scanf( ) es la función que permite recibir datos ingresados a través de teclado.