Manual

Cómo aprender a programar y no morir en
el intento – Parte 2
Tenemos harto que aprender hoy, y un recuento de lo pasado sería solo acumular líneas, así
que vamos, manos a la obra:
Contenidos:
Tal como lo prometimos en el tutorial anterior, hoy veremos los siguientes temas:
1. Áreas de memoria alias “Como almacena un computador la información”.
2. Introducción al Pseudo-Código.
3. Haciendo nuestro primer programa.
¿Listos?, ¿Fueron a buscar bebida?, yo no he ido, así que esperenme -> !.
1.-Áreas de memoria.
Quizás para gente más experimentada en el tema de la programación, pueda parecer algo
repentino entrar a esto tan luego, pero hay una razón de fondo que es empezar a
relacionarnos con el concepto de las variables de cierta forma.
Pero bueno, ¿Qué son las áreas de memoria?. Para contestar esta pregunta, nos haremos
otra, ¿Cómo almacena la información una máquina/equipo/computador?.
Básicamente lo hace de 2 formas, o mediante el uso de 2 tipos de memoria: la volátil y la no
volátil.
La memoria volátil es toda aquella que una vez que apagamos el computador se vacía (Ej:
Memoria RAM). Tiene la ventaja de ser de mayor acceso (lectura/escritura) y obviamente la
desventaja de que su almacenamiento no es “permanente”.
Por su lado la memoria no volátil es justamente lo contrario a la anterior, ya que una vez que
almacenamos información ahí, quedará hasta que decidamos borrarla o “alguien” lo decida
por nosotros. Ejemplos de memoria no volátil son los almacenamientos magnéticos (discos
duros) o los ópticos (CD, DVD, etc).
En la programación se utilizan ambos tipos de memoria. Por un lado se utiliza la memoria
volátil para el trabajo con variables (explicaremos eso en detalle) y por otro lado la memoria
no volátil cuando estamos trabajando con archivos o en otras situaciones que iremos viendo
a medida que ocurran.
En una representación gráfica, la memoria volátil que utiliza la programación (RAM), sería
algo como esto, guardando las proporciones:
Cada cuadradito representa un área de memoria, el cual posee una dirección expresada en
valores hexadecimales (algo por ejemplo como FA2246) la cual se llama dirección de
memoria, y es utilizada cuando se quiere acceder a los datos almacenados en ese
“cuadradito”.
¿Se acuerdan esa vez que les dijimos que explicaríamos las variables en detalle?, que
tiempos aquellos ¿no?, bueno el momento es ahora.
Las variables
Esta definición no intenta ser técnica ni mucho menos. Solo pretendemos que el concepto
quede claro para que lo intentamos lograr.
Una variable es un “enlace contenedor” de y a un dato. ¿Por qué enlace contenedor?, porque
una variable esta relacionada a una dirección de memoria, por ende enlace, y contiene un
valor correspondiente a un dato que podemos recibir o tomar de otro lado (usuario, otra
variable, el resultado de una operación, etc), ergo contenedor. Esta definición se irá haciendo
más clara a medida que vayamos avanzando.
Las variables tienen ciertas características, como son:
Nombre: Corresponde al identificador de la variable. Los nombres de variables dentro de un
programa deben ser únicos, no empezar con un número, no contener símbolos y respetar las
palabras reservadas dentro de un lenguaje de programación (Por ej: En Java, la palabra new
es reservada, por lo que no se puede nombrar una variable así).
Tipo: Corresponde al tipo de datos que podrán almacenarse en la variable. Si bien en
lenguajes como PHP no es necesario definir el tipo, la mayoría de los otros lenguajes lo
piden. Los tipos más comunes son:
1. Int: Corresponde a números enteros (correspondiente al universo Z de las
matemáticas). El rango que abarca (valores máximos y mínimos que se les puede dar)
varía del lenguaje en uso. Existen 2 variaciones comunes como son el short int o
short y el long int o long. Varían en el rango.
2. Float: Corresponde a valores de punto flotante (números decimales correspondientes
al universo Q de las matemáticas). En algunos lenguajes se puede utilizar como
double, short double o long double. Su rango difiere del lenguaje a utilizar.
3. Char: Corresponde a valores de caractéres alfanuméricos (0 a 9 y abecedario). Solo
se puede almacenar un valor dentro de este tipo de variables.
4. Boolean: Corresponden a valores de tipo lógico. Almacenan sólo 2 posibles valores:
true o false.
5. String: Corresponde a una cadena de caractéres, por ejemplo una palabra o frase. Su
rango depende de cada lenguaje.
Además debemos tener presente que las variables pueden cambiar su valor a lo largo del
programa (a no ser que sean definidas como constantes, ya veremos eso más adelante) y
existen observaciones sobre las operaciones que ejecutamos sobre ellas. Estos puntos los
detallaremos más adelante.
Dejando esa definición un poco más clara, volvemos al tema de las áreas de memoria.
Cuando creamos una variable, o bien la definimos, el equipo le asigna automáticamente un
área de memoria en la cual almacenará su valor. En caso de sobrepasar el área asignada, se
le asignará una nueva área de memoria, y así sucesivamente.
Esta sección de las áreas de memoria irá quedando cada vez más clara según vayamos
avanzando.
2.- Introducción al Pseudo-Código

El Pseudo-Código, como su nombre lo indica, es una especie de “lenguaje de programación”
utilizado para introducir a los futuros programadores a la estructura de la realización de
programas.
En él, se utilizan todos los recursos de un lenguaje de programación normal, a pesar de que
los nombres y conceptos puedan variar dependiendo de quien lo enseñe, y se busca
principalmente practicar un poco la lógica que posteriormente debemos implementar.
Lo principal que se debe entender, es que a pesar de establecer algunas reglas sobre como
se operará con el pseudo-código, los únicos errores que se pueden cometer son de lógica y
no como expresamos las distintas funcionalidades del programa, así que hay que irse
sintiendo lo suficientemente libres para experimentar.
Antes de entrar de lleno a este tema, es bueno detenernos y explicar un poco el tema de los
paradigmas de programación.
Paradigmas de programación
En la programación existen una serie de paradigmas que se refieren principalmente al
enfoque que le daremos a un problema para solucionarlo o bien “la forma en que veremos
las cosas”. Los paradigmas más comunes son:
1. Paradigma de programación estructurada.
2. Paradigma de programación orientada a objetos.
3. Paradigma de programación orientada a eventos.
4. Paradigma de programación orientada a aspectos.
Para las primeras etapas de estas guías nos enfocaremos en el paradigma estructurado. A
medida que vayamos avanzando nos interiorizaremos más en esto.
Volviendo al tema del Pseudo-código, y habiendo establecido el punto de los paradigmas,
veamos el formato clásico y básico de un programa:
Inicio
Definición/declaración de variables
Cuerpo del programa
Fin
A medida que vayamos haciendo programas más complejos veremos como este formato se
va a ampliando. Una explicación de las partes:
1. Inicio: Se refiere al comienzo del programa.
2. Definición/declaración de variables: Aquí indicamos todas las variables que
utilizaremos para la realización de nuestro programa, junto con su tipo y en algunos
casos, su valor inicial.
3. Cuerpo del programa: Aquí irá el desarrollo de nuestro programa, indicando
información que recolectaremos, operaciones y salidas (entrega de información).
4. Fin: Se refiere al fin del programa.
Cumpliendo esos pasos básicos, podemos empezar a hacer nuestros primeros programas.
Así que a tomar una hoja de papel, un lápiz y una goma, porque de seguro deberemos borrar
más de alguna cosa por ahí.
3.- Haciendo nuestro primer programa

Para hacer nuestro “bautizo oficial” en el mundo de la programación, partiremos por realizar
el ejercicio más clásico que aparece en todos los libros de programación de aquí a la
eternidad, el famoso “Hola mundo”.
En este programa lo que haremos será simplemente mostrar un mensaje en pantalla que
diga “Hola Mundo”. El código a continuación, y los comentarios van en negritas, cursiva y
entremedio de /* y */.
Ejercicio 1: Hola Mundo
Inicio
/* Establecemos el inicio del programa */
Principal( )
/* Definimos la función “Principal” que es donde irá el cuerpo del programa.

Ya adentraremos el tema de las funciones */
mostrar “Hola Mundo”;
/* Utilizamos la sentencia “mostrar” para enviar un mensaje que se

despliegue en pantalla y entre comillas la frase que mostraremos, en este
caso “Hola Mundo”. Luego de la sentencia ponemos un punto y coma para
indicar el fin de esta, algo que utilizaremos mucho cuando estemos
programando en algún lenguaje, ya que eso le indica al entorno de
programación que es el fin de la sentencia */
Fin
/* Finalizamos el programa */
Y así de simple. Hemos hecho nuestro primer programa enviando un mensaje “Hola Mundo”
que se mostrará en la pantalla. Para este programa, como solo mostramos un mensaje,
podrán ver que no hicimos uso de variables, por eso nos saltamos la parte de la definición de
ellas. En posteriores ejercicios haremos uso de eso.
Por hoy ya hemos visto bastante, así que es momento de asimilar la información y descansar
un poco. Para recapitular, hoy hemos aprendido sobre:
1. Áreas de memoria.
2. Variables.
3. Pseudo-código.
4. Paradigmas de programación.
5. Hicimos nuestro primer programa.
¿Bastante, no?, pues bueno, en la próxima guía nos enfocaremos principalmente en más
sobre Pseudo-código:
1. Definición de variables.
2. Leyendo datos desde teclado (ingresados por el usuario).
3. Iteraciones condicionales (Si, Si no).
4. Ciclos o búcles.
En una próxima edición, a la misma batihora y en el mismo baticanal.
Por ahora es mi deber recordar que como siempre, este tutorial ha sido desarrollado,
probado y documentado por el equipo de Como Lo Hago por lo que cuenta con nuestro
infalible y a veces programable Sello de garantía. Cualquier comentario, problema o duda
que puedan tener, sientanse libre de dejarnos unas líneas en el área habilitada a
continuación

Nota: Recomendamos leer las primeras 2 partes de esta guía si no lo han hecho, las cuales
pueden encontrarlas en:
• Parte 1.
• Parte 2.
Como es habitual, partamos por revisar los contenidos de esta edición:
Contenidos:
1. Definición de variables.
2. Leyendo datos desde teclado.
3. Operaciones matemáticas.
4. Iteraciones condicionales.
Es harta información, así que vamos de lleno a los temas:
1.- Definición de variables

En el tutorial anterior ya dimos una explicación de lo que son las variables y como se
encuentran involucradas en los procesos de la programación, por lo que hoy nos
enfocaremos solamente a su definición y uso dentro del código propiamente tal.
Las variables tienen lo que se llama un “ciclo de vida”, que representa toda la duración de
una variable a través de un programa. Este ciclo de vida se inicia con la definición o creación
de la variable y termina con la finalización del programa o la liberación del área de memoria
donde estaba contenida.
Para crear o definir una variable en pseudocódigo siempre se utiliza la siguiente sintaxis, la
cual representa fielmente la utilizada en los lenguajes de programación reales:
Tipo Nombre Valor Inicial (opcional)
Tal como vimos en el tutorial anterior, en los lenguajes de programación se utilizan ciertos
tipos para definir los tipos (valga la redundancia) de información que puede almacenar la
variable en cuestión. Les recomiendo revisar ese tutorial como recordatorio de los tipos que
vimos. En pseudocódigo utilizaremos los siguientes tipos:
1. Número: Este tipo de variables almacenarán cualquier valor de tipo número, ya sea
entero (conjunto Z) o bien real (conjunto R del universo de las matemáticas, o sea,
enteros más decimales). Cabe recordar que en los lenguajes reales hay distintos tipos
para los enteros y para los decimales, pero aquí los agruparemos todos dentro de este
mismo tipo.
2. Letra: Este tipo de variables almacenarán cualquier valor de tipo alfanumérico, ya
sean caracteres (0-9 o A-Z) o palabras y/o frases (como “gato”, o “la casa roja”). Tal
como en el tipo anterior, hay que recordar que en los lenguajes de programación
reales hay distintos tipos para tratar los caractéres y las cadenas de palabras, pero
aquí los agruparemos dentro de un mismo tipo.
3. Lógico: Este tipo de variables almacenarán valores de tipo lógico (verdadero o falso).
En vez de almacenar las palabras “verdadero” o “falso” le asignaremos un 0 si se trata
del primero y un 1 si se trata del segundo.
Vale la pena mencionar, que a pesar de que las variables de tipo Letra puedan almacenar
caracteres correspondientes a números, no podremos realizar operaciones matemáticas
sobre ellos, por lo que si necesitamos este tipo de operaciones es recomendable almacenar
en variables de tipo Número.
Durante el ciclo de vida de la variable (periodo entre su declaración y su fin) podemos
modificar su contenido cuantas veces queramos, siendo bastante útil al momento de querer
reciclar una variable para no tener que crear otra del mismo tipo, hecho que nos termina
ayudando a ahorrar memoria en uso.
Tal como indicamos en la sintaxis, toda variable debe llevar un nombre, el cual puede ser
cualquiera, pero debe respetar los siguientes criterios:
1. Debe ser único. No pueden haber 2 variables con el mismo nombre.
2. No puede empezar con un número ni un underscore. Sin embargo pueden
contenerlos dentro de su nombre. Si bien no se puede nombrar variables como
“2auto” o “_perro” si podemos tener otras como “auto2″ o “perro_”.
3. No pueden llevar como nombre una palabra reservada del lenguaje. Todos los
lenguajes tienen ciertas “palabras reservadas” que son utilizadas para definir tipos de
variables o funciones del lenguaje propiamente tal. Por ejemplo, nunca podríamos
nombrar una variable como “while” ya que los lenguajes reservan esa palabra para
una función de tipo ciclo. De a poco iremos conociendo las palabras que están
reservadas para cada lenguaje, aunque no hay de que preocuparse, ya que siempre
nos avisará al momento de compilar el programa y nos obligará a cambiarla para que
no hayan conflictos.
Además, indicamos en la sintaxis que a una variable podemos asignarle opcionalmente un
valor inicial. El “opcionalmente” se debe a que al momento de crear la variable podemos
asignarle un valor, pero si no lo hacemos no afecta, ya que lo podemos hacer más adelante.
Lo único en lo que hay que fijarse es que la variable contenga ya algún valor cuando
queramos operar con ella. Por ejemplo, si deseamos sumar un valor almacenado en una
variable, esta no puede estar en blanco.
Veremos a continuación, algunos ejemplos que cubren todo lo que hemos visto en las líneas
anteriores:
Retomando el ejemplo del “hola mundo” que vimos en el tutorial anterior, ahora en vez de
desplegar directamente el mensaje, lo desplegaremos con el uso de una variable.
(comentarios en negrita, cursiva y entre /* y */):
Inicio
Letra mensaje=”Hola mundo”;
/* A continuación definimos una variable de tipo “Letra”, de

nombre “mensaje” y le damos un valor inicial de “Hola mundo”, el
mensaje que queremos mostrar. Luego de la sentencia ponemos
un punto y coma para indicar el fin de esta, algo que utilizaremos
mucho cuando estemos programando en algún lenguaje, ya que
eso le indica al entorno de programación que es el fin de la
sentencia */
Principal( )
/* Definimos la función “Principal” que es donde irá el cuerpo del

programa. Ya adentraremos el tema de las funciones */
mostrar mensaje;

despliegue en pantalla y luego la variable que contiene el mensaje,
en este caso “mensaje”. Cerramos la sentencia con un punto y
coma para indicar que se ejecute la línea */
Fin
Como podemos ver, en este ejemplo hemos definido una variable de

tipo Letra, llamada mensaje y le hemos asignado como valor inicial el
mensaje que vamos a mostrar por pantalla. Ahora, ¿Qué pasa si no
queremos asignar un valor inicial, y se lo damos más adelante?, sería
algo como esto:
Inicio
Letra mensaje;
nombre “mensaje”. Luego de la sentencia ponemos un punto y
coma para indicar el fin de esta, algo que utilizaremos mucho
cuando estemos programando en algún lenguaje, ya que eso le
indica al entorno de programación que es el fin de la sentencia */
Principal( )

mensaje=”Hola mundo”;
/* Asignamos el valor “Hola mundo” a la variable mensaje y

cerramos con punto y coma*/
mostrar mensaje;

Fin
Esos son los pasos fundamentales para ir trabajando con variables.

Todo esto se irá haciendo cada vez más claro a medida que vayamos
desarrollando nuestros programas.
2.- Leyendo datos desde teclado

Hasta ahora, toda la información que hemos ido desplegando en nuestros programas ha sido
proporcionada por nosotros mismos, algo que cuando estemos realizando programas para
“terceros” nunca será suficiente, ya que muchas veces deberemos operar con información
proporcionada por los usuarios que utilizan los programas o por fuentes de datos externas.
Para esto se utiliza el término “Leer datos”.
Leer datos se refiere a recopilar información desde una fuente externa, ya sea un usuario
que los ingrese vía teclado, o de una fuente de datos como un archivo con registros o una
base de datos. En esta primera etapa nos centraremos en la lectura de datos desde teclado,
o sea, proporcionada por los usuarios.
Los datos se leen y se almacenan en una variable de tipo concordante al dato que se
ingresa, por lo que es muy importante definir el tipo de dato correcto, ya que si indicamos una
variable de tipo letra y el usuario ingresa un número, se guardará como caracter. Ya veremos
esto en más detalle en el ejemplo.
Esta información podemos manipularla de la forma que estimemos conveniente y despues
desplegarla en pantalla de la misma forma que lo hemos hecho hasta ahora.
Veamos un ejemplo, basandonos en el mismo ejercicio “Hola mundo” que hemos visto hasta
ahora. En vez de desplegar nosotros el mensaje, le diremos al usuario que ingrese un
mensaje para mostrar. (comentarios en negrita, cursiva y entre /* y */):
Inicio
Letra mensaje;

nombre “mensaje”. Luego de la sentencia ponemos un punto y
coma para indicar el fin de esta, algo que utilizaremos mucho
cuando estemos programando en algún lenguaje, ya que eso le
indica al entorno de programación que es el fin de la sentencia */
Principal( )

mostrar(“Ingrese un mensaje para mostrar: “);
leer(%letra,mensaje);
/* Utilizamos la función mostrar para desplegar un mensaje por

pantalla . Luego con la función leer indicamos entre parentesis el
tipo de dato que recolectaremos, en este caso letra (acompañado
de un porcentaje, esto es netamente para ir acostumbrándonos a
como leeremos los datos en lenguajes reales) y luego de la coma
el segundo parámetro, correspondiente a la variable donde
almacenaremos la información, o sea, mensaje. Terminamos todo
con un punto y coma. */
mostrar mensaje;

Fin
Con esto podemos recibir toda la infromación que necesitemos por

parte del usuario y desplegarla sin problemas en pantalla.
3.- Operaciones matemáticas

En los lenguajes de programación, una forma de realizar operaciones con los valores
almacenados en las variables es mediante las operaciones matemáticas. Los lenguajes
soportan las operaciones más comunes que podemos utilizar en la matemática y con ellas se
puede trabajar tanto variable vs variable, como variable vs constante, y constante vs
constante. Las operaciones más comunes soportadas son:
1. +: Suma.
2. -: Resta.
3. *: Multiplicación.
4. /: División.
5. Raíz cuadrada (la sentencia depende de cada lenguaje).
6. Potenciación (la sentencia depende de cada lenguaje).
7. %: Módulo de la división (resto).
8. ++: Incremento.
9. –: Decremento.
10.<: Menor a.
11.>: Mayor a.
12.==: Igual a. (Se debe usar doble signo ya que el signo simple es para asignar
valores).
13.!=: Distinto de.
14.&&: Y.
15.||: ó.
Hay algunas otras que iremos viendo más adelante.
Ahora veremos un ejemplo donde operaremos con un número ingresado por teclado
(comentarios en negrita, cursiva y entre /* y */):
Inicio
Numero edad;
Numero resultado;
/* A continuación definimos una variable de tipo “Numero”, de
nombre “edad” y luego una variable de tipo “Numero”, de nombre
“resultado”. Luego de la sentencia ponemos un punto y coma para
indicar el fin de esta, algo que utilizaremos mucho cuando
estemos programando en algún lenguaje, ya que eso le indica al
entorno de programación que es el fin de la sentencia */
Principal( )

mostrar(“Ingrese su edad: “);
leer(%numero,edad);
/* Utilizamos la función mostrar para desplegar un mensaje por

pantalla . Luego con la función leer indicamos entre parentesis el
tipo de dato que recolectaremos, en este caso numero
(acompañado de un porcentaje, esto es netamente para ir
acostumbrándonos a como leeremos los datos en lenguajes
reales) y luego de la coma el segundo parámetro, correspondiente
a la variable donde almacenaremos la información, o sea, edad.
Terminamos todo con un punto y coma. */
resultado=edad + 10;
/* En la variable resultado ahora almacenamos lo que nos dará el

sumarle 10 al valor ingresado para edad */
mostrar (“Su edad en 10 años sera: %numero”,resultado);

despliegue en pantalla, seguido del tipo de variable que
desplegaremos, o sea numero y luego la variable que contiene la
información, en este caso “edad”. Cerramos la sentencia con un
punto y coma para indicar que se ejecute la línea */
Fin
De esta forma desplegaremos un resultado de operar con un dato

ingresado por el usuario. Dentro de esas operaciones podemos hacer
todas las detalladas con anterioridad.
4.- Iteraciones condicionales

Dentro de la programación, en muchas ocasiones nos encontraremos con situaciones en
donde se deberá seleccionar uno de dos o varios caminos a seguir dependiendo de los datos
con los que se este trabajando. Para esto se cuenta con lo que se llama “iteraciones
condicionales”, lo que básicamente nos dará el pie de tomar un camino a seguir dependiendo
de una condición que indiquemos. Cada uno de estos caminos puede incluir una serie de
operaciones que perfectamente pueden ser distintas las unas de las otras.
La iteración condicional por excelencia es, en el caso del pseudocódigo el “Si” y “Si no”(if y
else en los lenguajes reales). Un “Si” puede o no llevar un “Si no”, mientras que un “Si no”
debe ir necesariamente a continuación de un “Si” ya que trabaja a partir de la condición
especificada más arriba. Además es bueno indicar que dentro de un “Si no”, pueden ir
infinitos “Si” y “Si no”.
Ejemplificando un poco esto, podría ser algo así:
Recogemos un dato respectivo a la edad de un usuario.
Si (edad cumple una condición)
sentencia 1;
sentencia 2;
Si no
sentencia 3;
sentencia 4;
Veamos un ejemplo práctico sobre el uso de estas iteraciones condicionales, basándonos en

el ejemplo anterior:
Inicio
Numero edad;
/* A continuación definimos una variable de tipo “Numero”, de

nombre “edad”. Luego de la sentencia ponemos un punto y coma
para indicar el fin de esta, algo que utilizaremos mucho cuando
estemos programando en algún lenguaje, ya que eso le indica al
entorno de programación que es el fin de la sentencia */
Principal( )

mostrar(“Ingrese su edad: “);
Si (edad > 18)
mostrar “Ud. es mayor de edad”;
Si no
mostrar “Ud. es menor de edad”;
/* Utilizamos la iteración condicional “Si” con la condición si la

edad es mayor a 18, y en caso de que sea desplegamos el mensaje
“Ud. es mayor de edad” con la función mostrar. Luego utilizamos
“Si no” lo que significa “Si no es mayor a 18″ y mostramos el
mensaje “Ud. no es mayor de edad con la función mostrar. */
Fin
Claramente el ejemplo anterior presenta una de las iteraciones

condicionales más básicas. Pueden realizarse modificaciones para
hacer iteraciones multiples e incluso más de una condición, ya sea
excluyente o no excluyente, pero eso lo veremos en una próxima
edición, ya que hoy hemos cubierto más que suficiente.
En la próxima edición de “Como aprender a programar y no morir en el intento – Parte 3″:
1. Iteraciones condicionales multiples y uso de más de una condición.
2. Switch: Otra iteración condicional.
Así que a armarse de paciencia, que hemos avanzado bastante pero aún queda un largo
camino por recorrer.

Nota: Si es primera vez que entran en estos tutoriales, les recomendamos leer las partes
anteriores para estar al día con lo que ya hemos cubierto:
• Parte 1.
• Parte 2.
• Parte 3.
Y tal como es costumbre, partiremos por revisar los contenidos de esta edición:
Contenidos:
1. Iteraciones condicionales múltiples y uso de más de una condición.
2. Switch: Otra iteración condicional.
Así que sin más que decir, manos a la obra:
1.- Iteraciones condicionales múltiples y uso de más de

una condición.
En la edición anterior de esta saga, comenzamos a ver lo que son las iteraciones
condicionales y como aplicarlas cuando dentro de un programa necesitamos tomar un
camino u otro, en su mayoría mutuamente excluyente, a partir de una condición dada. La
simpleza de su utilización pudimos apreciarla a través de los ejercicios resueltos.
Pero la programación, como la vida, siempre se complica, y eso es lo que haremos ahora.
En los ejercicios anteriores hicimos uso de condiciones excluyentes para las iteraciones, o
sea, algo como “Si se da esta condición, haga esto, si no, haga esto otro”, lo cual es bastante
sencillo de entender y aplicar. Sin embargo, cuando estemos realizando programas a más
alto nivel comunmente nos encontraremos con situaciones donde debamos evaluar multiples
iteraciones, como por ejemplo “Si se da esta condición, haga esto, si no se da, pero se da
esta otra, haga esto y si no se da ninguna de las 2, haga esto otro”. Con palabras es algo
complicado, pero viendo según sentencias, sería algo así:
Si (condición)
sentencia 1;
Si no
Si(condición)
sentencia 2;
Si no
sentencia 3;
Ahora, tal como mencionamos en el tutorial anterior, dentro de un Si, pueden ir una infinidad
de Si y Si no, lo mismo dentro de un Si no. Sin embargo, lo único que debemos recordar es
que siempre un Si no debe ir precedido de un Si.
Teniendo eso claro, ¿Qué pasa ahora si dentro de nuestro Si debemos evaluar más de una
condición o bien una de 2 posibles?.
Ahí es donde empezamos a utilizar el concepto de más de una condición. Dentro de un Si,
podemos evaluar el número de condiciones que nosotros queramos, utilizando los
operadores && para “y”, y || para “ó”. Por ejemplo, si dentro de un Si necesitaramos evaluar
la condición de que una persona tuviese más de 18 años y su nombre fuera Juan,
utilizaríamos algo como esto:
Si (edad > 18 && nombre==”Juan”)
sentencia 1;
Si no
sentencia 2;
Por otro lado, si quisieramos evaluar alguna de las 2 condiciones como ciertas, bien que su
edad sea mayor a 18, o su nombre fuese Juan, haríamos algo como esto:
Si (edad > 18 || nombre==”Juan”)
sentencia 1;
Si no
sentencia 2;
De esta forma, mediante esos operadores, podemos evaluar una serie de condiciones, tanto
excluyentes, como adherentes. Esta evaluación puede mezclarse con iteraciones múltiples,
según lo necesitemos.
2.- Switch: Otra iteración condicional.

A pesar de que el Si y Si no (if y else en los lenguajes reales) es la iteración condicional más
utilizada, existe una bastante útil al momento de evaluar distintos escenarios dentro de un
programa, la cual es el famoso Switch, el cual evalúa el valor de una variable y a partir de
ese valor presenta distintas sentencias a partir de posibles casos que se puedan dar.
Su funcionamiento es bastante parecido a la iteración anterior, pero en este caso lo que
basicamente se hace es:
Evaluación de la variable:
Si la variable es ‘x’:
Sentencia 1;
Salir;
Si la variable es ‘y’:
Sentencia 2;
Salir;
Si la variable es ‘z’:
Sentencia 3;
Salir;
Dentro de una iteración condicional Switch, podemos presentar todos los escenarios que
deseemos. Lo único a tener en consideración es que debemos conocer todos los posibles
valores que pueda tomar la variable para así plantear sus posibles desenlaces.
Además incluimos una nueva sentencia: Salir. Esta es utilizada debido a que por defecto,
una iteración condicional de tipo Switch recorre siempre todos los posibles escenarios (a
pesar de que no ejecuta las sentencias correspondientes a escenarios donde el valor no
corresponde), por lo que al agregar Salir, ejecutará las sentencias correspondientes y luego
saldrá de la iteración, ahorrando tiempo de ejecución.
Adicionalmente es bueno añadir un escenario de tipo defecto (default en los lenguajes
reales de programación), al cual se ingresará si el valor ingresado en la variable no
corresponde a ninguno de los escenarios posibles planteados. Esto quedará mucho más
claro más adelante cuando
Las iteraciones condicionales de tipo Switch son especialmente ideales al momento de
plantear menús dentro de un programa, ya que el usuario ingresará una opción y
conoceremos todos los posibles valores para plantear sus sentencias.
Existen una gran cantidad de casos donde podemos utilizar Si y Si no, o Switch, eso
dependerá del gusto de cada uno. Sin embargo en algunos casos no podremos utilizar
Switch, ya que la evaluación de valor se debe hacer con comparaciones exactas (Si el valor
es igual a 1 por ejemplo) y no comparaciones mediante operadores (Si el valor es mayor a
cierto valor).
Veamos ahora un ejemplo para que todo esto quede más claro. Utilizaremos un Switch
(llamándolo evaluar) para determinar opciones de un menú. (comentarios en negrita, cursiva
y entre /* y */).
Inicio
/* Damos inicio al programa */
Numero opción;
Letra nombre;
/* Declaramos una variable de tipo número y de nombre opción la cual
utilizaremos para que el usuario ingrese la opción del menú a la cual quiere
ingresar, y también una variable de tipo letra y de nombre ‘nombre’ la cual
usaremos dentro de las opciones del menú como ya veremos. */
Principal( )
{
/* Definimos la función “Principal” que es donde irá el cuerpo del programa,
además abrimos parentesis de llaves para incluir dentro todo lo
concerniente a esta función. Ya adentraremos el tema de las funciones. */
mostrar(“Seleccione una opción: \n”);

mostrar(“1.- Ingresar usuario \n”);
mostrar(“2.- Borrar usuario \n”);
mostrar(“3.- Listar usuarios \n”);
/* Mediante la sentencia mostrar, desplegamos un mensaje en pantalla para
que el usuario sepa que debe ingresar su opción y luego vamos mostrando
las opciones con la misma opción. Utilizamos “\n” para indicarle al programa
que haga un salto de línea */
leer(%numero, opcion);
/* Mediante la sentencia leer, recabamos el dato que quiere ingresar el
usuario. A leer le damos como parámetro primero el tipo de valor que
queremos recolectar, o sea número con un % antes para acostumbrarnos al
formato de lenguajes reales y luego le damos la variable donde
almacenaremos el valor, o sea, opcion */
evaluar(opcion)
{
/* Llamamos a la iteración evaluar y le damos como parámetro el dato en el
cual nos basaremos, o sea, opcion, luego abrimos llaves para dar inicio al
contenido de la iteración */
caso ‘1′: mostrar(“Ingrese el nombre del usuario: “);

leer(%letra,nombre);
…….
salir;
/* Definimos el caso ‘1′, que es decirle al programa “en caso de que la
evaluación nos diga que la opción seleccionada fue 1, haga esto” y luego
definimos las sentencias a ejecutar, finalizando con salir, tal como lo
explicamos anteriormente. /*
caso ‘2′: mostrar(“Ingrese el nombre del usuario a borrar: “);
leer(%letra,nombre);
……
salir;
/* Luego definimos el caso 2, tal como el anterior */
caso ‘3′: mostrar(“Los usuarios son: “);

…….
salir;
/* A continuación el caso 3 */
caso ‘defecto’: mostrar(“Seleccionó una opción no válida”);

salir;
/* Y finalmente el caso ‘defecto’ en caso de que haya seleccionado una
opción no definida para el menú. Luego de esta última definición, cerramos
el paréntesis de llave correspondiente a la iteración evaluar y el paréntesis
correspondiente a la función principal, y finalizamos el programa mediante
Fin. */
}
}
Fin
Como podemos ver, hemos utilizado el nuevo tipo de iteración y definido todos sus posibles
escenarios. Tal como indicamos anteriormente, en las iteraciones de este tipo solo podemos
evaluar valores fijos y no hacer comparaciones mediante operadores. Esto nos dará la pauta
sobre que tipo de iteración utilizar para cada caso.
Hora de pasar al último punto del tutorial de hoy:
3.- Ciclos o Búcles

Un aspecto importantísimo de la programación, es el uso de ciclos o búcles, los cuales son
utilizados en el 99,9% de los programas de alto nivel, ya veremos porque.
Hasta este momento, hemos desarrollado una serie de programas donde damos inicio,
ejecutamos algunas sentencias de forma ordenada, secuencial y estructurada y los
finalizamos. Con los conocimientos que poseemos hasta este punto, si quisieramos ejecutar
una operación un determinado número de veces, tendríamos que definir una línea para cada
vez que queramos ejecutar la operación, lo cual si el número de repeticiones es largo, se
convertiría en una operación tediosa y tendríamos un programa con un gran número de
líneas.
Para economizar este proceso y hacer todo mucho más sencillo es que aparecen los ciclos,
los cuales nos permiten ejecutar una sentencia un número de veces que nosotros
determinemos a partir de una condición dada.
Existen 3 ciclos comunes que se utilizan, cada uno de ellos con características especiales e
ideales para cierto tipo de usos:
1. Mientras (o while en los lenguajes reales): Se ejecuta si es que la condición dada se
cumpla y correrá tantas veces según se respete esa condición.
2. Haga Mientras (o do-while en los lenguajes reales): Se ejecuta tantas veces según se
respete la condición dada. A diferencia del Mientras, este ciclo se ejecuta al menos
una vez.
3. Para (o for en los lenguajes reales): Se ejecuta si es que la condición dada se cumple
inicialmente y mientras se siga cumpliendo. A diferencia de los 2 anteriores, en sus
parámetros definimos todas las condiciones necesarias.
Las diferencias quedarán claras en los ejemplos que daremos más adelante. Tal como en el
caso de las iteraciones condicionales, existen situaciones ideales para el uso de cada uno de
ellos. Sin embargo, hay una serie de casos donde podemos usar cualquiera de ellos de
forma eficiente.
Ahora, cuando usamos un ciclo, debemos definir ciertas cosas, como:
1. Una variable a utilizar en la condición que definirá la duración del ciclo, la cual puede
ser definida por nosotros o por un dato leído desde teclado.
2. Un valor inicial para esa variable, una vez más, definido por nosotros o por el usuario.
3. Una condición para evaluar esa variable y que definirá la duración de la ejecución del
ciclo.
4. Una instancia de cambio de la variable. Esta instancia, debe ir modificando el valor de
la variable para que en algún momento cumpla la condición que define la duración del
ciclo, de lo contrario, el ciclo se ejecutará infinitamente.
La diferencia entre cada tipo de ciclo se ve principalmente en la forma en que definimos y
utilizamos las cosas de la lista anterior.
Veamos unos ejemplos para que esto quede más claro:
Haremos un programa donde enumeremos del 1 al 100, utilizando los 3 tipos de ciclos
descritos con anterioridad. (comentarios en negrita, cursiva y entre /* y */ )
Inicio
Numero num=1;
/* Declaramos una variable de tipo Numero y nombre num, y le damos el
valor inicial 1, que es desde donde partiremos a enumerar */
Principal( )
{
/* Definimos la función “Principal” que es donde irá el cuerpo del programa y
abrimos llaves. Ya adentraremos el tema de las funciones */
mientras(num<=100)
{
mostrar(%numero, num);
num++;
}
/* Definimos un ciclo de tipo mientras y le decimos que la condición es que
se ejecute mientras num sea menor o igual a 100, dentro de el mediante la
sentencia mostrar desplegamos el valor actual de la variable y luego con el
operador de incremento lo aumentamos en uno y se vuelve a ejecutar. De
esta forma la primera vez que entre mostrará 1 y luego irá aumentando y
mostrando hasta que llegue a 100 */
haga
{
num++;
}mientras(num<=100);
/* Ahora hacemos la misma operación pero usando un ciclo de tipo haga-
mientras. Definimos las mismas operaciones pero a diferencia del caso
anterior, ahora declaramos la condición al final. Como requisito de este tipo
de ciclos, el mientras del final debe ir con un punto y coma al final.
Recordemos que este ciclo se ejecutará al menos una vez */
para(num=1;num<=100;num++)
{
}
/* Y finalmente hacemos el mismo proceso con un ciclo de tipo ‘para’. La
diferencia con los 2 anteriores es que ahora dentro de sus parametros
establecemos toda las condiciones para la ejecución de este ciclo. Partiendo
por un valor inicial para num, en este caso 1, la condición de duración que
es mientras sea menor o igual a 100 y el incremento para que se cumpla esta
condición. Dentro del ciclo solo ponemos la sentencia mostrar porque ya
hemos definido lo demás */
Fin
Como podemos ver, hemos declarado la misma operación mediante 3 ciclos distintos. Cada
uno de ellos desplegará el mismo resultado, los números de 1 a 100, pero la forma en que
definimos estos ciclos es diferente. Con más práctica podremos ir viendo que tipo de ciclo es
adecuado para que situación. Idealmente a la sentencia mostrar en los 3 casos podríamos
haberle añadido un salto de línea, porque como esta declarado mostrará los números uno al
lado del otro. Como es un ejemplo no es necesario que lo definamos.
Es bueno añadir que dentro de un ciclo, cualquiera de ellos, podemos definir todas las
operaciones que estimemos conveniente, incluidas iteraciones condicionales y todo lo que
hemos visto hasta ahora como muestra de datos, lectura de datos de teclado, etc.
Además es bueno también recordar que todo ciclo debe tener un fin, por eso debemos ser
cuidadosos al momento de definir las condiciones de duración, ya que un ciclo que corrá
eternamente matará nuestro programa.
Tal como debemos definir cuidadosamente el fin, un punto a considerar es que un ciclo no
necesariamente debe siempre ejecutarse, es por eso que definimos la condición de inicio y
duración. Por ejemplo, podemos condicionar el inicio de un ciclo a que cierta variable porte
cierto valor y en caso de que no lo tenga, el ciclo nunca se ejecute.
El trabajo con los ciclos puede presentar cierta complejidad en sus inicios, pero a medida que
vayamos avanzando se irá simplificando.
Con esto cerramos la lista de contenidos de esta edición del tutorial, definiendo que para el
próximo número, veremos:
1. Introducción a los arrays o arreglos.
2. Arreglos unidimensionales: Vectores.
3. Arreglos bidimensionales: Matrices.
Todo a la misma batihora, en el mismo baticanal.

Como es habitual, veamos lo que cubriremos en esta ocasión:
Contenidos
1.- Introducción a los arrays
2.- Vectores
3.- Matrices
Así que con todo especificado, vamos, a seguir aprendiendo:
Introducción a los arrays

Hasta ahora, todos los datos con los que hemos trabajado los hemos almacenado en
variables, las cuales entre sus características podemos indicar que son capaces de
almacenar un valor “simple”, o sea un número (de uno o más dígitos) o un carácter (o cadena
de ellos) o un valor booleano. De cualquier forma siempre almacenan solamente un y nada
más que un valor a la vez.
Pero, ¿qué pasa si es que necesitamos almacenar más de un valor?. Podríamos usar más
variables, sin embargo, cuando los valores necesarios de almacenar son 10 o más, disponer
de tantas variables, y más importante aún, recordar sus nombres y manipularlas, puede ser
bastante engorroso.
Para esto es que en la programación disponemos de los arrays o arreglos, los cuales son
variables que nos permiten almacenar más de un valor del mismo tipo y manipularlos, todo
dentro de la misma variable.
Comunmente en los lenguajes de programación, los arreglos solo pueden contener múltiples
valores del mismo tipo y hasta una longitud finita indicada al momento de su declaración. Sin
embargo, en algunos lenguajes especificos, existen tipos de arrays que no se apegan a estas
reglas (ya sea almacenando valores de distinto tipo o siendo dinámicos, o sea, creciendo a
medida que decidimos almacenar un nuevo valor en ellos).
Los arreglos pueden ser unidimensionales o bidimensionales. Los primeros en la
programación son conocidos como vectores, y los segundos como matrices.
Independiente de su dimensionalidad, los arrays deben cumplir con ciertas características,
algunas similares a las variables que hemos visto hasta ahora y otras no tanto.
1.- Nombre: Todo array debe tener un nombre, el cual debe cumplir con las mismas
características de los nombres de variable, o sea, debe ser único, no debe ser una palabra
reservada del lenguaje, ni empezar con números, guiones o underscores (pueden llevar
alguno de los 3 últimos entremedio).
2.- Tipo: Todo array debe tener un tipo, que corresponde al tipo de valores que se podrán
almacenar en el. Pueden ser los mismos tipos que para las variables vistas hasta ahora.
3.- Posición: Aquí entra la diferencia. Para facilitar la visualización, imaginémonos que una
variable común y corriente es una cajón en el que guardamos algo. Ahora, cuando pensamos
en un array, pensemos que es una cajonera, con un número de cajones, dentro de los cuales
se pueden almacenar varias cosas. Cada uno de estos cajones corresponde a una “posición
del array”. Cada posición es como si fuera una variable dentro del array y almacena un valor.
Después cuando queramos rescatar ese valor, se accede a la posición necesaria.
Veremos algunos esquemas ahora que especificaremos los tipos de arrays.
Vectores
Los vectores en la programación, son arrays unidimensionales en los cuales se pueden
almacenar múltiples valores (finitos) y que cuentan con las características anteriormente
definidas.
Para declarar un vector, en pseudocódigo, lo hacemos de la siguiente forma:
Numero vector[5];
Tipo nombre[largo];
El largo indicara cuantas posiciones tendrá el vector, y por ende, cuantos datos se podrán
almacenar.
Antes de seguir, debemos hacer una salvedad. En el mundo de la computación, siempre se
empieza a contar desde el cero y no el uno. Eso debemos tener en cuenta cuando queramos
acceder a una posición, ya que estaremos accediendo al número correspondiente a si
empezáramos a contar desde el cero. Por ejemplo, con ese vector que recién declaramos,
tendríamos algo como esto:
0 1 2 3 4
Si nos fijamos, a pesar de ser un vector de largo 5, sus posiciones van desde el 0 a la 4,
siendo estas a las que debemos acceder si queremos recuperar la información almacenada
ahí.
Para almacenar valores en un vector los asignamos de la misma forma que a una variable
común y corriente, a diferencia de que ahora debemos indicar el indice correspondiente a la
posición donde almacenaremos el valor, por ejemplo, si queremos almacenar el valor 2 en la
tercera posición de un vector de 5 posiciones:
Vector[2]=2;
Y si queremos leer el valor de un vector, lo hacemos de la misma forma. Por ejemplo, si

queremos comprobar un valor en un Si:
Si(vector[2]==2)
Tanto para ingresar datos, como para leerlos, una operación común es recorrerlos mediante
ciclos, ya sea con un ciclo de tipo Mientras o uno de tipo Para. Al hacer esto, declaramos una
variable para utilizar como indice, la cual se irá moviendo a lo largo del vector. Por ejemplo, si
quisieramos llenar un vector con números iguales a su indice, haríamos algo como esto,
asumiendo que el vector es de largo 5:
i=0;
mientras(i<5)
{
vector[i]=i;
i++;
}
Si en vez de ingresar datos, quisiéramos leerlos, lo hacemos de la misma forma.

Para resumir, veamos un ejemplo. En este caso lo que haremos será declarar un vector,
decirle al usuario que llene los valores para sus posiciones y luego las mostraremos por
pantalla.
Inicio
Damos inicio al programa
Numero vector[5];
Numero i=0;
Declaramos el vector y la variable que utilizaremos como índice para recorrerlo.
principal()
mientras(i<5)
{
Mediante un ciclo mientras, le mostramos un mensaje al usuario para que ingrese

el valor correspondiente a la posición del vector y luego leemos el dato.
mostrar(“Ingrese el valor %numero del vector”, i);
leer(vector[i], &numero);
i++;
i=0;
}
mostrar(“Los valores ingresados fueron: “);
Mostramos el mensaje avisando que desplegaremos los valores.
mientras(i<5)
{
Dentro de un ciclo mientras, mostramos todos los valores almacenados en el

vector.
mostrar(“%numero”, vector[i]);
i++;
}
Fin
Trabajar con vectores lleva un poco de costumbre, pero con práctica nos veremos
utilizándolos más y más a menudo y viendo como nos facilitan todo.
Matrices
Al igual que los vectores, las matrices son arrays. Sin embargo, a diferencia de ellos, son
bidimensionales, o sea operan en 2 dimensiones, a las cuales nos referiremos como filas y
columnas, como si fueran una especie de tabla.
Algo así:
Para declarar una matriz se hace igual que un vector, pero ahora en vez de indicar el largo,
debemos indicar el número de filas y el número de columnas. Como ejemplo:
Numero matriz[4][4];
Esa es una matriz cuadrada, de 4 filas y 4 columnas. No es necesario que siempre tengan el
mismo número de filas y de columnas. Al igual que en el álgebra, pueden variar.
Para el proceso de ingreso de datos en una posición de la matriz, debemos indicar su
posición relativa con respecto a filas y columnas. Por ejemplo, si quisieramos almacenar el
valor 8 en la segunda fila y primera columna, diríamos algo como esto:
matriz[1][0]=8;
Al igual que en los vectores, cuando queremos ingresar o leer múltiples datos, hacemos uso
de ciclos. La diferencia ahora es que para las matrices debemos utilizar 2 ciclos, uno que
recorra las filas y otro las columnas. Sería ejemplificado algo así, con una matriz de 4 x 4 y
llenando todas sus posiciones con un 8:
i=0;
j=0;
mientras(i<4)
{
mientras (j<4)
{
Matriz[i][j]=8;
j++:
}
i++;
}
Para recorrer sería el mismo proceso, pero en vez de ingresar datos, los leemos.
Veamos ahora un ejemplo, donde primero declararemos una matriz, luego le diremos a un
usuario que ingrese valores y finalmente los mostraremos:
Inicio
Damos inicio al programa.
Numero matriz[4][4];
Numero i=0;
Numero j=0;
Declaramos la matriz y las variables que utilizaremos para recorrerlas.
Principal()
mientras(i<4)
{
mientras(j<4)
{
Dentro de los 2 ciclos necesarios para recorrer filas y columnas en la matriz,

mostramos un mensaje para que ingresen un valor a esa posición y luego lo
leemos.
mostrar(“Ingrese el valor correspondiente a la fila %numero y la columna
%numero”,i,j);
leer(%numero, &matriz[i][j]);
j++;
}
i++;
}
i=0;
j=0;
mostrar(“Los valores ingresados son: “);
Avisaremos que mostraremos los valores
mientras(i<4)
{
mientras(j<4)
{
Mostramos los valores recorriendo la matriz con los 2 ciclos necesarios.
mostrar(“%numero”,matriz[i][j]);
j++;
}
i++;
}
Fin
Como podemos apreciar, es un proceso bastante sencillo. La mayor complejidad se presente

en poder entender el tema de los índices, pero una vez que lo logramos, todo se vuelve muy
simple.
Con este ultimo tema estamos llegando al final de esta edición, en la cual hemos cubierto el
tema de los arrays por completo, desde sus declaraciones hasta usos variados.
En la próxima edición:
1.- Funciones
2.- Ultimas consideraciones de Pseudo-codigo
3.- Entrando a un lenguaje real.
4.- Mas sobre los paradigmas de programación.
Nota: Tal como dice el título, esta es la 6ta parte de estas guías. Para un completo
entendimiento, recomendamos, si no lo han hecho, leer las partes anteriores, las cuales
pueden ser encontradas en la categoría de Programación de nuestros tutoriales.
Con eso claro, veamos los contenidos que cubriremos hoy:
Contenidos:
1. Funciones.
2. Ultimas consideraciones sobre Pseudo-código.
3. Entrando a un lenguaje real.
4. Más sobre los paradigmas de programación.
Como pueden apreciar, hay harto que cubrir, así que vamos directo a eso:
1.- Funciones.
El último tema que cubriremos sobre programación en pseudo-código propiamente tal, será
el de las funciones, el cual es un elemento de suma importancia tanto para estas etapas
tempranas como para cuando nos adentremos aun más en la programación.
Intentaremos simplificar este tema lo que más podamos. De cualquier forma, a pesar de la
complejidad que puede presentar, no se preocupen si no lo entienden a la perfección en un
comienzo, ya que a medida que vayamos viendo los ejemplos y en otros contenidos más
avanzados iremos comprendiendo bien este tema.
Hasta ahora, cada vez que escribíamos un programa y dentro de el necesitábamos tener
procedimientos de cálculo o manipulación de datos, los escribíamos línea por línea
estructuradamente dentro del principal de nuestro programa, algo así:
Definición de variable / asignación de valor
Operación 1
Operación 2
Operación 3
Asignación de resultados
Si las operaciones anteriores las necesitamos utilizar más de una vez o para distintas
variables, adicionalmente podíamos añadirlas dentro de un ciclo, si el tipo de variables nos lo
permiten, o bien repetir las operaciones dentro del programa las veces que sean necesarias.
Ahora, si la operación es de una sola línea, como una operación matemática por sí sola, no
presenta mayores complejidades ni costos repetirla todas las veces que sean necesarias. Sin
embargo, cuando hablamos ya de un proceso que contiene varias operaciones, y por ende
varias líneas de código, es cuando el tema se vuelve mucho más complejo y engorroso, ya
que nuestros programas empiezan a aumentar de tamaño y será mucho más costoso
(computacionalmente hablando) ejecutarlos.
Para esto es que se definen las Funciones, las cuales, como su nombre lo indica, ofrecen la
funcionalidad de agrupar y ejecutar una serie de operaciones, tanto por si solas como
dependiendo de ciertos parámetros que les entreguemos, y a la vez dándonos la opción de
retornarnos un valor que puede ser constante o variable dependiendo de los resultados de
las operaciones y cálculos internos de la función.
La programación está compuesta fundamentalmente de funciones, y hasta ahora, a través de
los contenidos y ejemplos, hemos utilizado una serie de ellas. Por ejemplo, la parte principal
que declaramos en cada programa que hacemos es una función, es la que contiene los
contenidos principales del programa que escribimos, valga la redundancia. A esa función no
le entregamos ningún tipo de parámetros y no nos retorna nada. Otras funciones que hemos
utilizado hasta ahora son las iteraciones condicionales (Si, Si no), los ciclos (mientras, para,
haga mientras) y otras como leer, mostrar, etc.
¿Qué ventajas presentan las funciones?
Principalmente orden, comodidad y economía. El uso de funciones nos permite no tener que
repetir operaciones según el número de veces que las vayamos a necesitar y en vez de eso
solo definirlas una vez y llamarlas cuando sea necesario. Eso también implicará que nuestro
programa sea mucho más liviano al momento de ejecutarse. Existen una serie de otras
ventanas que iremos descubriendo más adelante.
Las funciones se escriben fuera de la función principal (normalmente por orden, se escriben
después) y se definen de acuerdo a la siguiente estructura:
tipo nombre_función(parámetro 1, parámetro 2, etc.)
{
operación 1;
operación 2;
sentencia 1;
sentencia 2;
retorno de variable;
}
Donde:
1. Tipo: Detalla el tipo de valores que devuelve la función. Estos tipos pueden ser los
mismos que los de las variables, los cuales han sido especificados en los números
anteriores de esta saga. Sin embargo, no hay que confundirse, ya que por el hecho de
que una función sea de un determinado tipo, no significa que dentro de las
operaciones no puedan declararse y usarse variables de otros tipos, solo debemos
fijarnos que las variables que retornamos si lo sean. Se debe definir un tipo para la
función obligatoriamente.
2. Nombre de la función: Es un nombre único, tal como si estuviésemos definiendo una
nueva variable. El nombre de la función puede ser cualquiera, pero es recomendable,
por orden, darle un nombre adecuado. Por ejemplo si definimos una función que
encuentre el número máximo entre una serie de valores, es recomendable nombrar a
esa función como numero_maximo. De esa forma, siempre podremos ver que hace
cada parte de nuestro programa rápidamente cuando lo estemos revisando.
3. Parámetros: Tal como hemos definido en distintas partes de esta saga de tutoriales,
los parámetros que recibe una función son los que utilizará para operar dentro de ella
y devolver resultados. Normalmente las operaciones declaradas en una función son
procedimientos estándar que varían dependiendo de los valores que manejamos. En
una función podemos recibir múltiples parámetros y estos pueden ser de distintos
tipos, solo debemos asegurarnos de escribir primero el tipo y luego el nombre de ese
parámetro, tal como si definiéramos variables. Estos nombres no pueden repetirse
dentro de la función.
4. Operaciones y sentencias: Básicamente podemos hacer lo mismo que hacemos
dentro de nuestros programas, ya sea usar operadores matemáticos, iteraciones
condicionales, ciclos, mostrar, leer, etc. Todo está permitido.
5. Valor a retornar: Esto es opcional, una función puede o no retornar un valor, ya que
muchas veces el resultado podemos mostrarlo directamente en pantalla con la función
mostrar. Si decidimos devolver un valor, lo hacemos mediante la sentencia retornar
junto al valor o variable que enviemos. Solo debemos recordar que el valor o variable
retornado tiene que coincidir con el tipo de la función.
Con toda la definición ya más clara, veremos un ejemplo de declaración y uso de funciones:
Ejemplo: Realizaremos un programa en donde crearemos una función que defina que
número es mayor entre 2 entregados como parámetros. Los comentarios, como siempre, en
negrita, cursiva y entre /* y */:
Inicio
Numero num1, num2, mayor;

/* Declaramos 3 variables de tipo Número: num1 y num2 que serán 2 números
que el usuario ingresará por teclado, y mayor, que será donde se almacenará el
número mayor después de que la función nos devuelva el resultado */
principal ( )
{
/* Declaramos la función principal del programa */
mostrar(“Por favor ingrese el número 1: “);

leer(%numero, &num1);
mostrar(“Por favor ahora ingrese el número 2: “);
leer(%numero, &num2);
/* Mediante mostrar y leer, recibimos por teclado los 2 números ingresados por el
usuario */
mayor=numero_mayor(num1, num2);
/* A la variable mayor, le asignamos el resultado de llamar a la función
numero_mayor, especificada luego de la función principal, pasándole como
parámetros las variables num1 y num2 */
mostrar(“El número mayor de los que ingreso es: %numero”, mayor);

/* Nuestra variable mayor ya recibió el resultado de la función, así que lo
desplegamos */
}
numero numero_mayor(numero valor1, numero valor2)
/* Declaramos una función de tipo numero, llamada numero_mayor y que recibe

como parámetro 2 variables de tipo numero, llamadas valor1 y valor2, que
corresponden a los num1 y num2 enviados desde arriba */
Si(valor1 > valor2)
{
retornar valor1;
}
Si no
{
retornar valor2;
}
/* Mediante una iteración condiciional, hacemos una comparación entre los 2
números y retornamos el mayor de los 2 para que se le asigne a la variable mayor
y se muestre por pantalla al usuario. */
}
Fin
Con este simple ejemplo hemos podido apreciar un poco el funcionamiento y uso de las
funciones en la programación. Hay un importante concepto que hemos utilizado ahora, pero
que detallaremos más en profundidad cuando estemos hablando de lenguajes reales, que es
el paso de parámetros desde una función a otra (lo que hicimos cuando llamamos a la
función y lo que esta recibe por el otro lado). Por ahora no vale la pena entrar en esos
detalles, pero ya los veremos más completamente.
Con las funciones sucede lo mismo, esta pasada que le hemos dado ahora es bastante
superficial, pero iremos cubriendo otros aspectos y descubriendo sus usos completos y más
complejos a medida que vayamos programando más y más. Por ahora es una buena técnica
ir combinando los otros contenidos que hemos visto en los capítulos anteriores con esto e ir
practicando. Por ahora, al siguiente tema.
2.- Últimas consideraciones sobre el Pseudo-código:

En estos momentos que estamos llegando al final de nuestra cobertura sobre el pseudo-
código o pseudo-lenguaje, es bueno repasar algunas consideraciones antes de adentrarnos
al lenguaje real en el que decidamos programar, por ejemplo:
1.- Recordemos que el pseudo-lenguaje no es un lenguaje de programación real, y por ende,
lo que hemos cubierto hasta acá no lo encontrarán en libros o puede que aparezca de forma
distinta. No se preocupen, el objetivo nunca ha sido ni será que nos convirtamos en expertos
de pseudo-código, si no que entendamos como se desarrollan los procedimientos en la
programación y como plantearnos soluciones a los problemas mediante el entendimiento de
la estructura de los programas.
2.- El pseudo-código, a pesar de no ser un lenguaje real, utiliza un paradigma estructurado y
por la forma y palabras que normalmente se uilizan, se asemeja bastante al lenguaje C, por
lo que es la opción natural para seguir. Veremos más de esto en el próximo punto.
3.- Lamentablemente, al no tratarse de un lenguaje real, no existe ningún software que
podamos utilizar para programar y así ver nuestros errores para poder solucionarlos. Esto
por un lado es bueno, ya que agudiza nuestra forma para leer el código y detectar errores,
algo que nos servirá de sobremanera más adelante.
4.- Es recomendable que repasemos e intentemos entender de la mejor forma todos los
puntos explicados en esta y pasadas ediciones de esta saga. Si bien hemos cubierto una
pequeña parte de todo lo que comprende la programación, hasta ahora hemos visto las
bases fundamentales para entender los lenguajes reales y todo el resto de aplicaciones
dentro de la programación, por lo que entender de la mejor manera estas bases será
esencial para que la enseñanza no se complique más adelante.
3.- Entrando a un lenguaje real:

Ahora que hemos de alguna forma “terminado” con el pseudo-lenguaje ha llegado un
momento importante: Decidir el lenguaje de programación que empezaremos a aprender.
Esta decisión no es sencilla, y depende de varios factores, entre ellos el paradigma de
programación, la facilidad del lenguaje, la extensibilidad y funcionalidades, actualización con
los tiempos e incluso preferencia personal entre muchas otras razones.
Al momento de elegir debemos tomar esas consideraciones, aunque también fijarnos en
otras como la documentación disponible, grupos de usuarios y todo lo que nos pueda apoyar
a que el aprendizaje sea más sencillo.
Como experiencia personal, y el camino que seguiremos en esta saga de tutoriales, una de
las mejores opciones para continuar es el lenguaje C, esto debido a lo similar que es al
pseudo-código que hemos visto y porque ambos comparten el mismo paradigma
estructurado, con lo que la transición se hace mucho más sencilla y así es posible pasar a
otros lenguajes con mayor facilidad en el futuro. Así que prepárense, que para allá vamos.
4.- Más sobre los paradigmas de programación:

Tal como veíamos en este tutorial, actualmente existen 4 paradigmas comunes de
programación, como son (ojo que son definiciones básicas, para que nos hagamos la idea de
cada uno):
1. Paradigma estructurado: Es el paradigma que hemos estado viendo hasta ahora con
el pseudo-lenguaje y que luego veremos con C. Este paradigma, como su nombre lo
indica, expresa una declaración y funcionamiento estructurado para sus programas, en
donde desde arriba a abajo en una misma “plantilla de programa” debe estar el inicio,
la declaración de las variables del programa y las funciones (la principal y otras
funciones). Todo definido desde su inicio a su final. Además, los lenguajes
estructurados se enfocan principalmente en el tratamiento de datos, recibiéndolos,
operando con ellos y mostrando resultados. No tienen más profundidad que eso.
2. Paradigma orientado a objeto: A diferencia del estructurado, en este paradigma,
todo se trata como un objeto, cada uno de ellos con atributos, tal como si habláramos
de objetos del mundo real. Los lenguajes de POO (programación orientada a objetos),
operan mediante distintas clases, que son plantillas que determinan el comportamiento
de un objeto. Pueden haber clases donde se determine un objeto, sus atributos y los
métodos (parecido a las funciones) que se aplican a ellos y otras clases donde solo se
encuentre el método principal (como la función principal). Este es un paradigma
mucho más complejo que no queremos detallar por ahora para no confundirnos,
porque el paso desde un lenguaje estructurado a uno POO complica al principio, pero
no se preocupen, ya lo veremos.
3. Paradigma orientado a eventos: En este paradigma se habla de lenguajes que
dentro de un programa, presentan una serie de acciones que están “siempre listas” y
se encuentran en espera para dispararse de acuerdo a un evento que ocurra
(normalmente ejecutado por un usuario). Por ejemplo, tenemos programas como Word
o Excel, que en sus menús y botones cuentan con múltiples mini-programas listos
para ejecutarse cuando el usuario presione el botón o seleccione el menú. Por ahora
no adentraremos más en esto, por las mismas razones el caso anterior.
4. Paradigma orientado a aspectos: Este es un paradigma que actualmente se
encuentra bajo investigación, por lo que no hay gran información disponible.
Decidimos mencionarlo más por anécdota que por cubrirlo propiamente tal. Quizás
cuando estemos en números futuros de esta saga podamos ir adelantando más
información.
Con esto podemos tener un poco más claro por qué existen distintos lenguajes de
programación y que los diferencia, es principalmente su paradigma.
Para casos de esta saga, por las razones antes descritas, seguiremos con el lenguaje C, el
cual nos servirá de base para todo el aprendizaje que tendremos que hacer.
Por ahora lo dejaremos hasta aquí, ya que hemos cubierto suficiente y es momento de tomar
un descanso hasta tutoriales futuros donde ya empezaremos a utilizar un lenguaje real de
programación.
1. Introducción al lenguaje C.
2. Variables en C.
3. Funciones básicas.

Viendo que ahora ingresaremos a la programación propiamente tal, es bueno indicar los:
Implementos necesarios:
1. Un entorno de programación en C (recomendamos Dev C/C++ de Bloodshed, un buen
entorno de programación que además es gratuito. Ese es el que utilizaremos a través
de los siguientes tutoriales. Pueden descargarlo en este enlace).
Con todo eso claro, vamos a los contenidos que cubriremos hoy:
Contenidos:
1. Introducción al lenguaje C.
2. Librerías.
3. Variables en C.
4. Funciones básicas.
5. Primer programa en C.
1.- Introducción al Lenguaje C:

Nota: La instalación del entorno de programación, hemos decidido no cubrirla, ya que es
bastante estándar en lo que a instalaciones de programas se refiere. Les recomendamos
hacer la instalación de forma normal, dándole siguiente en las ventanas y dejando las
opciones que vienen por defecto. Más adelante indicaremos si es necesario hacer cambios
sobre esto.
Y bueno, llegamos al momento que tanto esperabamos: Empezar a trabajar con lenguajes
reales de programación.
Para comenzar, hemos optado por el lenguaje C, debido a que por su forma y paradigma, es
un buen y simple lenguaje para continuar el aprendizaje. Además, como iremos viendo a
medida que nos adentremos en los siguientes capitulos, tiene mucha similitud con el Pseudo-
código que hemos visto hasta ahora.
C es un lenguaje de programación que fue creado en 1972 en los laboratorios Bell. Utiliza un
paradigma estructurado (también denominado como imperativo y/o procedural) y presenta
una eficiencia notable en su código, además de características de bajo nivel que permiten
controlar algunos aspectos de memoria y perifericos, por lo que se convierte en la elección
favorita e idónea al momento de desarrollar aplicaciones e incluso desarrollos para Sistemas
Operativos.
Los programas desarrollados en C, presentan una estructura bastante similar a la que
habíamos visto hasta el momento en Pseudo-código, con algunas adiciones (como las
librerías, que ya veremos) y uno que otro cambio, sobretodo en las palabras reservadas y
algunas formas de definir cosas. Todo esto lo iremos viendo a su debido tiempo.
En resumen, algunos puntos a considerar para el futuro:
• Los programas en lenguaje C, se escriben en entornos de programación, en realidad
si queremos podemos escribirlos en block de notas, pero los entornos de
programación presentan funcionalidades que nos hacen la vida mucho más fácil,
desde la detección de errores hasta la orientación sobre algunas palabras reservadas
y/o comandos.
• En C, tal como en otros lenguajes, al momento de terminar nuestros programas, en el
entorno de programación podemos “compilarlos”, lo que significa que el entorno hará
una revisión del programa completo en busca de errores y nos advertirá sobre ellos
para poder corregirlos.
• Entre los tipos de errores que se pueden presentar al momento de compilar o terminar
un programa, principalmente tenemos 2: los léxicos y los sintácticos. Los primeros
se refieren a cuando tenemos algo dentro de nuestro programa que está mal escrito,
por ejemplo si en vez de un ciclo while escribimos whlie. Por otro lado tenemos los
errores sintácticos, que se refieren a cuando lo que hemos escrito no tiene sentido, por
ejemplo el querer asignar un valor numérico a una variable de tipo carácter o algo por
el estilo.
Iremos viendo más sobre estas y otras consideraciones y detalles a medida que vayamos
avanzando en nuestro aprendizaje.
2.- Librerías:
Un punto muy importante dentro de la programación, en especial en el lenguaje C, son las
famosas y nunca bien ponderadas librerías.
¿Qué es una librería?
Una librería es una plantilla que contiene una serie de funciones, las cuales
pueden ser utilizadas por un programa que ha invocado esta librería al inicio. Las
librerías normalmente representan una “categoría” de funciones (por ej. existe una
librería donde están todas las funciones matemáticas más comunes) y de acuerdo
a eso las invocamos.
El lenguaje C nos proporciona múltiples librerías para nuestras necesidades, por lo

que cada vez que necesitemos realizar una determinada acción, podemos hacer
una búsqueda de la función y por ende librería correspondiente. Adicionalmente,
podemos crear nuestras propias librerías y utilizarlas libremente (así como otras
que han sido creadas por otros usuarios y puestas a disposición en Internet).
Podemos reconocer las librerías por su extensión que es la letra “h”. Por ejemplo,
si tuviéramos la librería comolohago, la encontraríamos como comolohago.h.
Estas librerías se encuentran en el directorio include de nuestra instalación
correspondiente al entorno de programación.
Tal como indicabamos en la definición, las librerías deben ser invocadas o en estricto rigor
“incluidas” en el programa donde las vayamos a utilizar. Para esto, al inicio, en las primeras
líneas de nuestro programa, debemos utilizar la sentencia #INCLUDE y el nombre de la
librería entre < y >. Por ejemplo, si quisiéramos incluir la librería “ejemplo.h”, pondríamos al
inicio de nuestro programa:
#INCLUDE <ejemplo.h>
Podemos incluir las librerías que queramos (siempre que existan). Sin embargo, no es
recomendable incluir librerías que no vayamos a utilizar, ya que es un gasto extra sobre el
programa. En caso de que alguna de las funciones, o sentencias de nuestro programa
necesite de una librería que no hayamos incluido, al momento de compilar nos lanzará un
error avisándonos del hecho.
Antes de concluir con el capítulo sobre las librerías, es bueno añadir que las más comunes
que se usan en prácticamente el 100% de los programas en C son las librerias stdlib.h y
stdio.h, por lo que siempre es bueno añadirlas. Otra de las comunes es la conio.h, pero no
es utilizada todo el tiempo y probablemente no la requeriremos hasta que vayamos mucho
más adelante.
3.- Variables en C:
Al igual que en Pseudo-código, en lenguaje C, así como en otros lenguajes, contamos con
variables para almacenar, operar y mostrar datos.
No entraremos en detalles sobre definiciones de que es una variable, porque esos temas ya
los hemos cubierto en números anteriores. Nos dedicaremos de lleno a cubrir las variables
en C, las cuales son muy similares a las que utilizabamos en Pseudo-lenguaje. Entre las más
comunes que utilizaremos:
1. int: Se utilizan para almacenar y operar con números enteros (correspondiente al
conjunto Z de las matemáticas). Pueden almacenar tanto enteros positivos como
negativos hasta un cierto rango (-32768 a 32767). Existen 2 variaciones que son el
short int y el long int, los cuales varían en el rango permitido.
2. char: Se utilizan para almacenar caracteres, tal como el tipo Letra de Pseudo-código.
3. float: Se utilizan para almacenar y operar con números decimales (correspondiente al
conjunto Q de las matemáticas). Adicionalmente se pueden utilizar para almacenar
números enteros, pero no es lo recomendable. Su rango va entre 3,4 *E-38 (elevado
a) hasta 3,4 * E+38 (elevado a).
4. boolean: Almacenan datos de tipo booleano. Pueden tener 2 valores: true o false.
Esas son las variables principales que utilizaremos al programar. Iremos conociendo otras y
viendo variaciones de estas mismas a medida que vayamos adentrándonos más y viendo
más ejemplos.
4.- Funciones básicas:

En nuestros primeros programas de Pseudo-código, utilizamos una serie de funciones
básicas para leer datos desde teclado o mostrarselos al usuario, así como operaciones
matemáticas y otras cosas similares que nos ayudaron a llevar a cabo nuestros programas
más simples.
En C tenemos estos mismos operadores y funciones, con unas leves diferencias como
veremos a continuación:
a) La Función Principal: En Pseudo-código utilizabamos la función principal ( ) que era
donde escribíamos el cuerpo del programa. En C también tenemos una función principal,
pero la diferencia es que aqui tiene un tipo (tipo int) y su nombre es main. Entonces, para
declarar la función principal decimos:
int main( )
{
código del programa
}
Adicionalmente, podemos decir que la función main de C, cuenta con 2 parámetros como
argc (de tipo int) y argv (de tipo char, es un vector). Estos parámetros corresponden a
argumentos que nosotros le podemos dar a un programa particular, siendo el primero un
entero que indica el número de argumentos, y el segundo un vector de tipo char que contiene
en cada posición los argumentos que enviamos. Esto es un poco avanzado, así que no lo
veremos aún, pero podremos apreciar que es bastante útil.
b) Mostrando información por pantalla: Cuando queríamos mostrar algún tipo de
información en pseudo-código, utilizabamos la sentencia mostrar. En C, utilizaremos printf,
la cual se utiliza de la misma forma que la veníamos utilizando hasta ahora, es decir:
printf(“mensaje”);
o bien
printf(“%tipo de variable”,nombre de la variable);
Se puede utilizar una combinatoria de ambas. En la parte de %tipo de variable, utilizamos los
tipos definidos en el lenguaje C, como por ejemplo:
%d: Si la variable es un entero (int).
%f: Si la variable es un decimal o punto flotante (float).
%c: Si la variable es un caracter (char).
c) Leyendo información desde teclado: Tal como debemos recordar, en pseudo-código
utilizabamos la sentencia leer. En lenguaje C, utilizaremos scanf, que funciona de la misma
forma que la hemos utilizado hasta ahora, es decir:
scanf(“%tipo de variable”,&nombre de la variable);
Como podemos apreciar, hay una diferencia con el caso de printf, y es que acá al momento
de hacer un scanf, al lado del nombre de la variable añadimos un &. Esto es necesario, ya
que así le decimos al programa que guarde la información en el área de memoria que
asignamos para esa variable cuando la declaramos. A esa área de memoria accedemos con
&.
Cuando incluimos una sentencia de tipo scanf, el programa se detiene hasta que el usuario
ingresa datos y presiona enter, por lo que tenemos la seguridad que el resto del programa no
se ejecutará hasta que se cumpla esa acción.
d) Operadores matemáticos y lógicos: Son bastante similares a los que utilizabamos en
pseudolenguaje, o sea:
• +: Suma.
• -: Resta.
• *: Multiplicación.
• /: División.
• <: Menor que.
• >: Mayor que.
• ==: Igual a. (un solo igual es asignación de valor, no comparación).
• !=: Distinto que.
• %: Módulo, o resto de la división.
• ++: Incremento en uno.
• –: Decremento en uno.
Existen otros que iremos viendo a medida que los vayamos necesitando.
5.- Primer programa en C:
Para terminar con el capitulo de hoy, nos tomaremos un pequeño descanso de tanta teoría, y
realizaremos nuestro primer programa en C. Para eso, crearemos un archivo fuente donde
estará nuestro código en nuestro entorno de programación (Si instalaron Dev-C++ vamos al
menú Archivo > Nuevo > Archivo Fuente o bien presionamos CTRL + N) con lo que se
abrirá una plantilla en blanco. Ahí es donde escribiremos el código.
Entonces bien, tal como fue clásico en pseudo-código, aquí lo seguirá siendo, así que
haremos nuestro nunca bien ponderado Hola Mundo, pero ahora en C. El código a
continuación, y los comentarios como siempre, en negrita, cursiva y entre /* y */:
#include <stdlib.h>
#include <stdio.h>
/* Partimos por incluir las librerías stdlib.h y stdio.h mediante #include */
int main() /* Declaramos la función principal */

{
printf(“Hola Mundo”); /* Mostramos el mensaje */
}
Con el código escrito, no nos queda más que probar nuestro programa. Así que primero
vamos al menú Ejecutar > Compilar o bien presionamos CTRL + F9 en nuestro teclado.
Esto nos pedirá guardar el programa y se abrirá una ventana, ahí colocamos como nombre
holamundo.c (o bien el que uds quieran pero con la extensión .c) y en tipo seleccionamos C
source files (*.c).
Guardamos y el entorno de programación compilará (o sea revisará el programa que
escribimos en busca de errores). Si encuentra algún error, nos indicará abajo donde está la
falla. De lo contrario nos dirá que está listo y sin errores, por lo que presionamos Cerrar en la
ventana de aviso.
Luego, vamos al menú Ejecutar > Ejecutar o bien CTRL + F10 en nuestro teclado, y nuestro
programa correrá (no saldrá corriendo, sino que se ejecutará).
¿Funcionó?, ¿Se ejecutó y desapareció?, no se asusten. No hay nada malo con el programa.
Es el entorno de programación que por defecto cuando un programa termina, cierra la
ventana de ejecución. Por ahora haremos un pequeño truco para poder visualizar nuestro
programa de forma correcta.
Añadiremos luego del mensaje, una función básica de C llamada getch();, la cual cumple la
función de dejar el programa en espera hasta que el usuario presione una tecla, así
podremos ver el resultado. Así que nuestro nuevo código quedaría de la siguiente forma:
#include <stdlib.h>
#include <stdio.h>
int main()
{
printf(“Hola mundo”);
getch();
}
Compilamos y ejecutamos de nuevo y veremos la ventana con el resultado de nuestro

programa, o sea, el mensaje “Hola Mundo”. Para cerrar solo presionamos una tecla.
Y con eso terminamos por hoy, donde hemos dado nuestros primeros pasos en el lenguaje C
e incluso hemos realizado nuestro primer programa.
1. Leyendo datos de teclado.

Nota: Como es habitual, les recomendamos, si no lo han hecho ya, leer los números
anteriores de esta saga, que pueden encontrar en la categoría de Programación de CLH.
Tal como prometimos en el número anterior, en este veremos los siguientes contenidos:
Contenidos:
1. Comentarios.
2. Leyendo datos desde teclado.
5. Ejercicio: Programando un terminal de venta simple.
Veremos bastante hoy, así que vamos, manos a la obra:
1.- Comentarios.
Si nos hemos fijado hasta ahora, siempre que realizamos algún ejemplo o ejercicio de
código, en C, Pseudo-código o bien en nuestros tutoriales de PHP, siempre ponemos las
explicaciones entre unos símbolos /* y */.
Esto, junto a otros símbolos, es lo que en la programación (a todo nivel) se conoce como
comentarios.
Los comentarios en la programación, si bien no son obligatorios, se convierten en una
herramienta util y su mayor función es entregarnos la posibilidad de añadir pequeñas
anotaciones sobre lo que estimemos conveniente, ya sea sobre el código propiamente tal u
otras cosas como notas de autoría o funcionamiento del programa en sí.
¿Por qué usar comentarios?
Principalmente por un tema de orden. Tenemos que pensar de que si bien nuestra memoria
puede ser excelente, en más de alguna ocasión nos tocará revisar códigos que hayamos
realizado hace algún tiempo y puede que en ese programa hayamos utilizado alguna función
o lógica que no tiene sentido en este momento. Por eso el uso de comentarios nos simplifica
el tener que estar mucho tiempo deduciendo lo que alguna vez hicimos. Lo mismo se presta
para cuando nuestro código es revisado por terceros o bien nosotros revisamos códigos
hechos por alguien más.
Hay 2 formas de comentarios: los de línea simple y los de múltiples líneas. La única
diferenciación es en los símbolos que utilizamos para iniciar y terminar los comentarios.
Cuando los comentarios son de línea simple solo debemos añadir al principio de la línea el
símbolo // . Debemos tener en cuenta de que solo será válido como comentario lo que
escribamos en la misma línea. Si pasamos a otra línea lo tomará como código y nos lanzará
error, por lo que debemos utilizar símbolo de comentario de múltiples líneas.
Para múltiples líneas, utilizamos el mismo que hemos usado hasta ahora, o sea al principio
del comentario ponemos /* y al final del comentario cerramos con */. Todo lo que escribamos
entremedio será considerado como comentario.
De cualquier forma, si es que les complica recordar los símbolos para cada caso, pueden
utilizar siempre el formato de múltiples líneas, que cubre comentarios ya sea en 1 línea o en
varias.
2.- Leyendo datos desde teclado.

Cuando trabajabamos en Pseudo-código, una de las funcionalidades que más utilizabamos,
era la lectura o recepción de datos ingresados por un usuario vía teclado. Eso nos permitía
interactuar de una mayor forma con quien utilizaba el programa y realizar procesamientos
mucho mejores y personalizados.
Pues bien, en C también podemos leer datos desde teclado, de una forma tan similar como
en pseudolenguaje. Si recordamos el tutorial anterior, hablábamos de la función scanf, la
cual nos permitía realizar esa tarea y que se utiliza de la siguiente forma:
scanf(“%tipodevariable”, &nombredelavariable);
Como podemos observar, esta función presenta 2 parámetros: %tipodevariable (entre

comillas) y &nombredelavariable, los cuales a su vez presentan 2 signos: % y &. Vamos por
parte explicando:
1. tipodevariable: Tal como hemos visto en numerosas ocasiones, cada variable que
definimos en un programa contiene un tipo de datos que puede almacenar (int, float,
char, etc). A su vez, el lenguaje C utiliza unos simbolos que representan esos tipos y
que se incluyen en las funciones scanf y printf para decirle al compilador que tipo de
dato es el que estamos leyendo/mostrando. Estos simbolos son la d para variables de
tipo int, la f para variables de tipo float y la c para variables de tipo char entre otras.
2. El símbolo %: Este símbolo siempre debe ir por obligación acompañando a los
símbolos indicados en el punto anterior, de esta forma el compilador comprenderá que
estamos hablando de un tipo de dato y no de una consonante por sí sola.
3. nombredevariable: Es el nombre que le damos a una variable en particular cuando la
definimos.
4. El símbolo &: En el lenguaje C, cuando utilizamos el símbolo & junto al nombre de
una variable, le estamos diciendo al compilador que nos estamos refiriendo al área de
memoria en el que esa variable almacena su información. Como dijimos hace algún
tiempo, toda variable al momento de ser creada, apunta a un área de memoria interna
del computador para manipular su información. A esta área accedemos con el símbolo
& cuando leemos un dato.
Con esas definiciones claras, veamos un pequeño ejemplo, para lo que utilizaremos el
entorno de programación que instalamos en el número anterior:
Ejemplo: Realizar un programa que lea un dato numérico por teclado y luego mostrarlo por
pantalla. (La explicación del código, como siempre en negrita, cursiva y entre /* y */.
#include <stdio.h>
#include <stdlib.h>
#include <conio.h>
/* Partimos por agregar las librerías necesarias para nuestro programa,

incluida la conio.h para hacer uso de la función getch( ); */
int numero;
/* Declaramos una variable llamada numero de tipo int */
int main( )
{
/* Declaramos la función main o principal */
printf(“Ingrese un numero del 1 al 10: “);

/* Mostramos un mensaje al usuario para que ingrese un numero del 1 al 10 */
scanf(“%d”, &numero);
/* Con scanf leemos el dato, indicando con %d que es un dato de tipo int e
indicamos que guardaremos la información en el área de memoria de la
variable numero poniendo &numero */
printf(“Ingreso el numero %d”, numero);

getch();
/* Mostramos el numero que ingreso el usuario, poniendo un mensaje con
printf y en la posición donde mostraremos el número ponemos el símbolo
correspondiente al tipo de dato, o sea %d, y luego de la coma la variable que
mostraremos. En la línea siguiente ponemos un getch ( ); para que el
programa quede en espera hasta que presionemos una tecla y así podamos
ver el resultado antes que se cierre */
} // Cerramos llave de la función main.
Compilamos el programa y no deberíamos tener errores. Lo ejecutamos y probamos que

funcione.
Así de simple es la captura de datos vía teclado.
3.- Iteraciones condicionales.

Las iteraciones condicionales en C son bastante similares a las que vimos en pseudocódigo
(Si y Si No, Switch) y cumplen exactamente la misma función, esto es, ejecutar una serie de
acciones a partir del cumplimiento de una condición. No entraremos en mayor detalle, pues
lo vimos de forma bastante completa en el pasado.
En lo que si adentraremos es en como se usan en C:
Si y Si no
En C se utiliza de la misma forma, radicando la diferencia en que en vez de ser Si y Si no,
hablamos de if y else. Esta iteración tiene las mismas características que en pseudo, o sea,
todo else debe ir luego de un if y dentro de un if y de un else pueden ir múltiples if y elses. La
forma de declaración es:
if(condición)
{
sentencia 1;
sentencia 2;
}
else
{
sentencia 3;
sentencia 4;
Cuando utilizamos if y else, podemos o no usar llaves para abrir y cerrar el if. Cuando un if
y/o un else tienen solo una sentencia a ejecutar, podemos escribirlos sin llaves para abrir y
cerrar. Si es más de una sentencia, necesariamente deben llevar llaves. Si desean, para
evitar confusiones, podemos utilizar siempre las llaves.
Veamos un ejemplo ampliando el caso anterior. También pediremos un dato al usuario, pero
en vez de mostrarlo lo someteremos a un simple if y else para ver si el número es mayor a 5:
#include <stdlib.h>
#include <stdio.h>
#include <conio.h>
int numero;
int main()
{
printf(“Ingrese un numero del 1 al 10: “);
scanf(“%d”,&numero);
/* Primero vemos con un if si el numero es igual a 5. Recordemos que para

comparar utilizamos doble signo igual */
if(numero==5)
printf(“El numero ingresado es 5″);
else // Si no es igual a 5
if(numero > 5) // Si es mayor a 5 mostramos el mensaje
printf(“El numero ingresado es mayor a 5″);
else // Si es menor a 5 mostramos el mensaje
printf(“El numero ingresado es menor a 5″);
getch();
A medida que vayamos avanzando, el uso de if y else será más complejo y largo, pero la
lógica es básicamente la misma.
La iteración switch la veremos en el próximo número, ya que implica un mayor nivel de
detalle y no queremos extendernos por sobre los demás contenidos de momento.
4.- Ciclos o búcles.

Tal como las iteraciones, en pseudolenguaje también definimos y utilizamos ciclos y búcles
que cumplen la misma funcionalidad que en C, por lo que no nos desviaremos definiendo
nuevamente esos temas, si no que veremos cada caso para C y luego un ejemplo que los
reune a todos.
Mientras
El ciclo mientras que usabamos en Pseudocódigo, en C (y otros lenguajes) es conocido
como while y es uno de los más usados. La forma de utilizarlo es la misma, o sea:
while(condición)
{
sentencia 1;
sentencia 2;
}
Tal como en Pseudo, este ciclo sólo se ejecutará (y se mantendrá en ejecución) mientras la
condición se cumpla.
Para
Este ciclo en lenguaje C es conocido como for y se utiliza de la misma forma, o sea:
for(inicialización de variable ; condición ; aumento o decremento de la variable)
{
sentencia 1;
sentencia 2;
sentencia 3;
}
Tal como en el caso del ciclo while, este ciclo se continuará ejecutando mientras se cumpla
la condición, pero a diferencia del anterior, este siempre se ejecutará, ya que la variable para
la condición se inicializa dentro del propio ciclo.
Haga mientras
Corresponde al ciclo do-while, bastante similar al caso del while pero con 2 diferencias. Este
ciclo se ejecutará al menos 1 vez aunque la condición no se cumpla y el while del final debe
ir con punto y coma, o sea:
do
{
sentencia 1;
sentencia 2;
sentencia 3;
}while(condición);
Tal como en pseudolenguaje, hay ocasiones ideales para el uso de cada tipo de ciclo, pero
en muchas ocasiones podemos usar cualquiera de los 3 y dependerá más que nada del
gusto personal.
A continuación veremos un ejemplo en donde utilizaremos los 3 ciclos para resolver un
mismo problema.
Ejercicio: Enumerar del 1 al 10 utilizando los 3 ciclos vistos hasta ahora.
#include <stdlib.h>
#include <stdio.h>
#include <conio.h>
int numero;
int main()
{
numero=1; // Asignamos el valor inicial a la variable
while(numero<=10) // Partimos con un ciclo while
{
printf(“%d\n”,numero); /* Mostramos el número y utlizamos \n para hacer salto
de línea */
numero++; // Incrementamos el valor
}
for(numero=1;numero<=10;numero++) // Seguimos con un ciclo for

especificando los parámetros
{
printf(“%d\n”,numero); // Mostramos el número
}
numero=1; // Reinicializamos el número a 1
do // Terminamos con un ciclo do-while

{
printf(“%d\n”,numero); // Mostramos el número
numero++; // Incrementamos el valor
}while(numero<=10); // Definimos la condición
getch(); // Dejamos el programa en espera
Luego de compilar y ejecutar podemos ver que como resultado se enumerará del 1 al 10, 3
veces seguidas, 1 por cada ciclo que definimos.
5.- Ejercicio: Programando un terminal de venta simple.

Ahora que hemos visto aspectos básicos del lenguaje C, desarrollaremos un ejercicio en el
que combinaremos todos los conocimientos adquiridos hasta ahora.
Lo que haremos será programar un terminal de venta simple, en donde primero
desplegaremos una lista de productos, luego pediremos el código del producto, la cantidad
que se desea llevar y mostraremos el total a cancelar. No nos complicaremos mucho y en el
futuro iremos añadiendo nuevas funcionalidades. Así que manos a la obra:
#include <stdlib.h>
#include <stdio.h>
#include <conio.h>
int codigo, cantidad, valor, total, vuelto, pago; /* Declaramos las variables que
usaremos, todas de tipo int */
int main()
{
printf(“\t Lista de productos\n”); /* Partimos por listar los productos,
utilizamos \t para separar los textos, tal como si utilizaramos la tecla TAB */
printf(“Codigo\t Nombre\t Precio\n”);
printf(“1\t Silla\t 100\n”);
printf(“2\t Puerta\t 350\n”);
printf(“3\t Sillon\t 200\n”);
printf(“\nIngrese el codigo del producto que desea llevar: “); /* Solicitamos el

código del producto*/
scanf(“%d”,&codigo); /* Leemos el código */
printf(“\nIngrese la cantidad que desea llevar: “); /* Solicitamos la cantidad que
llevarán */
scanf(“%d”,&cantidad); /* Leemos la cantidad */
if(codigo==1) /* Comparamos mediante iteraciones el código para asignar el

valor total */
valor=100;
if(codigo==2)
valor=350;
if(codigo==3)
valor=200;
total=valor*cantidad; /* Multiplicamos el valor por la cantidad para obtener el

total */
printf(“\nEl total es de: %d”,total); /* Mostramos el total */

printf(“\nIngrese el pago: “); /* Solicitamos el pago */
scanf(“%d”,&pago); /* Leemos el pago */
if(pago<total) /* Vemos mediante un if si el pago es suficiente */
printf(“\nEl pago no es suficiente”);
else
{
vuelto=pago-total; /* Obtenemos el vuelto */
printf(“\nEl vuelto es de: %d”,vuelto); /* Mostramos el vuelto */
}
printf(“\nVenta finalizada”); /* Damos el mensaje de despedida */
getch();
Y así tenemos nuestro simple terminal de venta. Como podemos apreciar, este programa no
es lo suficientemente óptimo, ya que solo podemos realizar 1 venta por sobre 1 sólo
producto, así que su aplicación es bastante limitada. Para poder realizar múltiples ventas o 1
venta de múltiples productos es necesario el uso de ciclos para poder repetir las acciones
necesarias.
Desde ya los incentivamos a que vayan modificando este programa y agregando esa
funcionalidad. De cualquier forma en las próximas lecciones le iremos añadiendo más y más
cosas a este programa para crear una aplicación mucho más completa.
Con esto damos por terminada la lección de hoy, hemos cubierto bastante y aún nos queda
un largo camino por recorrer, así que mucha paciencia.
En la próxima edición de Como aprender a programar y no morir en el intento veremos:
1. Iteración Switch.
2. Vectores.
3. Matrices.
4. Terminal de venta – 2da parte.

Nota: Como siempre, les recomendamos, si es que no lo han hecho, leer los números
anteriores de esta guía, los cuales pueden ser encontrados en nuestra categoría de
programación.
Si recuerdan el número anterior, en esta ocasión veremos:
Contenidos:
1. Iteración Switch.
2. Vectores.
3. Matrices.
4. Continuación de la confección de un terminal de venta.
Así que vamos de lleno a la guía de hoy:
1.- Iteración Switch:

En el número anterior, veíamos las iteraciones condicionales if y else, las cuales nos
permitían tomar distintos caminos dentro de un programa, dependiendo de una condición
determinada. Además, cuando veíamos los números sobre pseudo-lenguaje, conocímos una
iteración llamada Switch, la cual presentaba una funcionalidad bastante similar, pero tal
como explicábamos aquella vez, es bastante mejor para usar en casos determinados.
El funcionamiento de esta iteración, ya lo hemos detallado en números anteriores, por lo que
no adentraremos en repetir lo mismo, si no que veremos como funciona en lenguaje C.
Ahora, una buena pregunta, es ¿Cuándo usar if/else y cuándo usar switch?. La verdad, es
que como todo en la programación, es cosa de gustos. A pesar de que pueden haber casos
en los que sea más cómodo y/o ordenado usar una iteración sobre otra, las 2 cumplen la
misma funcionalidad, por lo que pueden ser usadas sin problemas. En lo personal, lo cual en
ningún sentido es un estándar, prefiero usar iteraciones de tipo Switch cuando en los
programas definimos algún tipo de menú, por un tema de orden. En un ejemplo más adelante
podremos apreciar porque.
Entonces, usando switch en C, lo primero que necesitamos es una variable que tome un
valor (todo switch debe ser inicializado por una variable) y conocer los valores, o la mayoría
de ellos, que pudiése tomar, como veremos en el siguiente ejemplo.
Además, dentro de los casos, podemos definir un caso por defecto, el cual cubrirá todas las
opciones no definidas. Esto es muy útil para prevenir que el usuario ingrese un valor que no
tenemos cubierto dentro de nuestras opciones.
Veamos un ejemplo.
Ejemplo: Plantearemos un pequeño menú, y definiremos cada caso, utilizando una iteración
de tipo switch.
#include <stdlib.h>
#include <stdio.h>
#include <conio.h>
int opcion;
int main()
{
/* A continuación escribimos nuestro menú, tabulando y dando saltos de
línea */
printf(“\tMenu”);
printf(“\n1.- Mostrar hola mundo”);
printf(“\n2.- Dar los buenos dias”);
printf(“\n3.- Salir”);
printf(“\nIngrese su opcion: “);
scanf(“%d”,&opcion); /* Leemos la opción que ingrese el usuario */
switch(opcion) // Activamos el switch con la variable opción.

{
case 1: printf(“\nHola mundo”); /* En el caso que ingrese 1 */
break;
case 2: printf(“\nBuenos dias”); /* En el caso que ingrese 2 */
break;
case 3: break; /* En el caso que ingrese 3 */
default: printf(“\nOpcion no valida”); /* Caso por defecto */

break;
}
getch(); /* Ponemos el programa en pausa hasta que se presione una tecla */
}
Como podemos ver, al final de cada caso, debemos incluir la sentencia break;, que indicará
que después de ejecutar las sentencias correspondientes al caso, se debe salir del switch.
Compilamos y probamos. Ahora, como podrán apreciar, este switch solo se ejecuta una vez.
En caso de que quisieramos hacerlo repetitivo hasta que se diga salir, podemos insertarlo
dentro de un ciclo y poner como condición que se ejecute mientras no se seleccione la
opción de salida.
Así de simple es la iteración switch. Es de gran utilidad para ordenar nuestras opciones y en
especial para utilizarlo con menús, así que es muy recomendable aprender a usarlo y
manejarlo para los programas que vayamos a desarrollar.
2.- Vectores:
Tal como veíamos en pseudo-lenguaje, en la programación existen unas variables especiales
conocidas como arreglos, las cuales presentan la facultad de almacenar múltiples valores, ya
sea unidimensionalmente o bidimensionalmente. Los vectores representan los primeros.
En C, también podemos utilizar vectores, de la misma forma en la que los planteabamos para
pseudocódigo, es decir, declarándolos y rellenándolos según su posición, así como las
mismas condiciones para recorrerlos y leerlos.
Tal como en todos los casos, no entraremos a repetir las definiciones que hemos hecho en
guías anteriores y sólo nos preocuparemos de su uso en lenguaje C.
Veamos un pequeño ejemplo, para que nos quede todo más claro:
Ejemplo: Declararemos un vector, lo rellenaremos y luego mostraremos su contenido:
#include <stdlib.h>
#include <stdio.h>
#include <conio.h>
int vector[5]; // Declaramos el vector
int main()
{
for(int i=0; i<5; i++) /* Definimos un ciclo para llenar el vector */
{
printf(“\nIngrese el valor de la posicion %d del vector: “,i);
scanf(“%d”,&vector[i]); /* Leemos los datos de cada posición */
}
printf(“\nLos valores ingresados fueron: “); /* Mostramos los valores */
for(int i=0;i<5; i++)
{
printf(“%d\t”,vector[i]);
}
}
Como podemos ver, el procedimiento es el mismo que usabamos para pseudo-código,

utilizando ciclos tanto para rellenar posiciones secuencialmente, como para leerlas,
accediendo mediante el índice que marcamos con la variable i, que se va moviendo a lo largo
del vector.
Ahora, si nos fijamos en el ejemplo, podemos ver que dentro del ciclo for, hemos definido la
variable i y no al principio del programa. Esto es posible en este tipo de ciclos, pero esa
variable solamente vive dentro del búcle y no después (por eso la volvemos a declarar en el
segundo ciclo). Esta es una gran forma de matar variables rápidamente después de su uso y
no gastar espacio innecesariamente.
3.- Matrices:
En el caso de las matrices, utilizamos procedimientos bastante similares a los de los
vectores, salvo que, siendo arreglos bidimensionales, para recorrer una matriz necesitaremos
de 2 ciclos, uno para las filas, y 1 para las columnas.
La definición también varía en el número de dimensiones que declaramos. Si para los
vectores hacíamos una declaración del tipo “vector [5]“ por su unidimensionalidad, para las
matrices aplicamos una definición del tipo “matriz [5[[5]“, la primera relacionada con sus filas,
y la 2da con sus columnas.
Veamos un ejemplo para que nos quede más claro.
Ejemplo: Repetiremos el ejemplo anterior, pero en este caso utilizaremos una matriz:
#include <stdlib.h>
#include <stdio.h>
#include <conio.h>
int matriz[3][3]; // Declaramos la matriz
int main()
{
for(int i=0; i<3; i++) /* Definimos un ciclo para las filas */
{
for(int j=0; j<3; j++) /* Otro ciclo para las columnas */
{
printf(“\nIngrese el valor para la fila %d y la columna %d: “,i,j);
scanf(“%d”,&matriz[i][j]);
}
}
printf(“Los valores ingresados son:\n “);
for (int i=0; i<3; i++) /* Mostramos los valores ingresados, tabulando y dando
salto de línea para hacer la forma de la matriz */
{
for (int j=0; j<3; j++)
{
printf(“%d\t”,matriz[i][j]);
}
printf(“\n”);
}
}
El procedimiento es el mismo, pero solo nso enfocamos en recorrer 2 dimensiones en vez de

una. A medida que vayamos utilizando vectores y matrices en nuestros programas nos
iremos acostumbrando cada vez más a su funcionamiento.
4.- Terminal de venta:

Si recuerdan, al final del número anterior, realizamos la confección de un terminal de venta,
en el cual listabamos unos productos y realizabamos una venta, especificando el vuelto
correspondiente al cliente.
Hoy, seguiremos trabajando sobre ese terminal, añadiendo la funcionalidad de poder vender
más de un producto en una venta y de realizar más de una venta. Si recordamos, teníamos
este código:
include <stdlib.h>
#include <stdio.h>
#include <conio.h>
int codigo, cantidad, valor, total, vuelto, pago;
int main()
{
printf(“\t Lista de productos\n”);
printf(“\nIngrese el codigo del producto que desea llevar: “);

scanf(“%d”,&codigo);
printf(“\nIngrese la cantidad que desea llevar: “);
scanf(“%d”,&cantidad);
if(codigo==1)
valor=100;
if(codigo==2)
valor=350;
if(codigo==3)
valor=200;
total=valor*cantidad;
printf(“\nEl total es de: %d”,total);

printf(“\nIngrese el pago: “);
scanf(“%d”,&pago);
if(pago<total)
else
{
vuelto=pago-total;
printf(“\nEl vuelto es de: %d”,vuelto);
}
printf(“\nVenta finalizada”);
getch();
Y ahora, añadiendole algunos ciclos, tendremos un código como este:

#include <stdlib.h>
#include <stdio.h>
#include <conio.h> /* Incluimos las librerías */
usaremos en el proceso */
int ok=1; /* Adicionalmente declaramos una variable ok, que nos servirá de
bandera para un ciclo que usaremos */
int opcion=1; /* Declaramos una variable opcion, que regulara si queremos
hacer más de una venta */
int main()
{
while(opcion==1)
{
while(codigo!=4) /* Definimos un ciclo que se ejecute siempre que el usuario
no presione la tecla para finalizar la venta */
{
printf(“\t Lista de productos\n”); /* Listamos los productos */
printf(“\nPara cerrar la venta, presione 4″); /* Añadimos la opción para cerrar la
venta */
printf(“\nIngrese el codigo del producto que desea llevar: “); /* Pedimos el código
del producto */
scanf(“%d”,&codigo); /* Leemos el código del producto */
if(codigo==4) /* Si el código es igual a 4, significa que la venta está finalizada,
así que cerramos el proceso de venta */
break;
printf(“\nIngrese la cantidad que desea llevar: “); /* Pedimos la cantidad */
if(codigo==1) /* Igualamos el código para asignar el precio */

valor=100;
if(codigo==2)
valor=350;
if(codigo==3)
valor=200;
total=total+(valor*cantidad); /* A total le asignamos, el total acumulado hasta

ahora, más el nuevo valor y nueva cantidad, multiplicados entre sí */
}
printf(“\nEl total es de: %d”,total); /* Saliendo de la venta, indicamos el total */
while(ok==1) /* Declaramos un ciclo con la variable ok, para el proceso de
pago y vuelto, así se ejecutará hasta que se pague la cantidad correcta */
{
if(pago<total) /* Si el pago es inferior al total, mostramos un mensaje de error
*/
else /* De lo contrario, cambiamos el valor de ok para romper el ciclo y
mostramos los mensajes de vuelto */
{
ok=0;
vuelto=pago-total;
}
}
printf(“\n¿Desea hacer otra venta? (1=Si , 0=No): “); /* Preguntamos si desea

hacer otra venta */
scanf(“%d,”,&opcion); /* Leemos la respuesta */
}
printf(“\nVenta finalizada”); /* Mensaje final */
getch(); /* Programa en pausa hasta pulsar una tecla */
Como podemos apreciar en esta nueva versión, hacemos uso de algunos ciclos. De esta
forma, podemos hacer una venta de múltiples productos, y validamos el pago hasta que sea
el correcto, para así completar de forma correcta la venta. Además, luego de finalizar una
venta, podemos hacer otra automáticamente al señalarlo y de esta forma no necesitamos
volver a ejecutar el programa cada vez que queramos vender algo.
Recordemos que nuestro programa lo vamos construyendo de a poco, aún hay muchos
puntos que pueden ser mejorados y eso es lo que iremos haciendo en los próximos números.
Por ahora lo dejaremos aquí, pero los incentivamos a que vayan añadiendo nuevas cosas de
lo que hemos ido aprendiendo.
En la próxima edición de “Cómo aprender a programar y no morir en el intento”:
1. Método de ordenamiento: El método de la burbuja.
2. Método de busqueda: Búsqueda secuencial.
3. Funciones.
4. Continuación del términal de ventas: Añadiendo un menú.

Tal como adelantábamos en el número anterior, los contenidos de hoy:
Contenidos
1. Métodos de ordenamiento: Método de la burbuja.
2. Métodos de búsqueda: Método secuencial.
3. Funciones.
4. Añadiendo un menú al terminal de venta.
Vamos, manos a la obra:
1.- Métodos de ordenamiento: Método de la burbuja.
En un escenario normal, el 99,9% de los programas que realicemos operan con una cantidad
de datos mediana a alta, los cuales pueden ser o no ingresados por un usuario y son
almacenados en distitnos medios, ya sea en variables, arreglos o archivos entre otras cosas.
Ahora, en un escenario más normal aún, estos datos nunca estarán necesariamente
ordenados bajo algún criterio en particular, por lo que si necesitaramos acceder a ellos bajo
un orden especial, sería imposible lograrlo por si solo.
Para esto es que en la programación existen los métodos de ordenamiento, los cuales son
básicamente algoritmos que realizan una lectura de una serie de datos y un posterior
ordenamiento de acuerdo a ciertos criterios (alfabeticamente, menor a mayor, etc).
Existen una serie de métodos de ordenamiento como el de la burbuja, quicksort, inserción,
selección, etc. Cada uno de ellos se diferencia del otro tanto en su funcionamiento como en
el costo (de ejecución) que significan para el programa en sí.
¿Qué método utilizar?
Si bien, como decíamos, cada método presenta ciertas ventajas por sobre otro, en ningún
caso son diferencias radicales y en estricto rigor no se notan a menos que trabajemos con
cantidades másivas de datos, por lo que el consejo por ahora es utilizar el método que
encontremos más sencillo y/o nos acomode más. A pesar de esto hay escenarios que
presentan una mejor adaptabilidad a un método en particular. Ya iremos viendo más de esto
en futuras guías.
Partiendo veremos uno de los métodos más conocidos y utilizados como es el método de la
burbuja, llamado de esta forma por la forma en que se realiza el ordenamiento de datos,
emulando una burbuja.
¿Cómo funciona el método de la burbuja?
Este método, utilizado comunmente cuando se necesita ordenar datos dentro de un vector o
una matriz, funciona mediante el uso de 4 variables:
1. Un vector o matriz donde están almacenados los datos.
2. Una variable que recorre el vector.
3. Una variable que recorre el vector una posición más adelante que la variable anterior.
4. Una variable auxiliar.
La forma de funcionamiento es bastante simple: Nuestro vector es recorrido por una variable
(la definida en el número 2) y por otra en una posición más adelante. Vamos realizando una
comparación entre las 2 variables y si se cumple el criterio establecido se hace un
movimiento circular: El valor más adelantado pasa a la variable auxiliar, el valor más
atrasado pasa a la posición adelantada y el valor de la variable auxiliar pasa a la posición
retrasada. Esto se realiza hasta que se alcanza el final del vector en cuestión.
Veamos un ejemplo de este método de ordenamiento:
Ejemplo: Ordenar un vector de tamaño 5 de menor a mayor mediante el método de la
burbuja (los comentarios, como siempre, en negrita, cursiva y entre /* y */):
#include <stdio.h>
#include <conio.h>
#include <stdlib.h> // Incluimos las librerías
int main()
{
int arreglo[5], aux, i, j;
/* Declaramos las siguientes variables:
arreglo = Un vector de 5 posiciones donde tendremos los valores.

i,j = Variables para recorrer el vector.
aux = Variable para guardar un valor mientras lo ordenamos
*/
printf (“Ingrese valores para llenar el vector:\n”);

// Mostramos un mensaje e introducimos valores al vector
for (i=0; i< 5; i++)
scanf(“%d”,&arreglo[i]);
/* Luego, ordenamos el vector mediante el algoritmo de burbuja:
Recorremos el vector con una variable más adelantada que la otra y

comparamos. Si el valor de la posición actual es mayor al de una
posición más, guardamos el valor actual en la variable auxiliar,
luego en la posición actual ponemos el valor de la posición siguiente
y en la posición siguiente guardamos el valor de la variable auxiliar*/
for (j=1; j <= 5; j++)

for (i=0; i< 4; i++)
if (arreglo[i] > arreglo[i+1])
{
aux = arreglo[i];
arreglo[i] = arreglo[i+1];
arreglo[i+1] = aux;
}
printf (“\nValores ordenados exitosamente!\n”);

// Mostramos el vector ordenado
for (i=0; i< 5; i++)
printf (“arreglo[%d] = %d\n”, i, arreglo[i]);
getch();
}
Como podemos ver, es un algoritmo bastante simple que cumple la función solicitada,
ordenar de menor a mayor aplicando el método de la burbuja. Existen otros métodos que
serán de mayor utilidad cuando trabajemos con una cantidad de datos mayor, pero por ahora
con este podremos cumplir el objetivo sin problemas.
2.- Métodos de búsqueda: Método secuencial

Una funcionalidad que siempre es útil al momento de hacer un programa, es la de poder
buscar un dato específico del que necesitamos saber información o bien trabajar con el.
En lenguajes de programación de 3a generación, orientados al proceso, como C, existen una
serie de métodos de búsqueda que nos permiten cumplir esa tarea, entre ellos podemos
destacar la búsqueda secuencial, la binaria, acceso directo y el trabajo mediante índices.
¿En que se diferencian?, tal como en el caso de los métodos de ordenamiento, cada uno de
estos métodos se separa de otro por la forma en la que trabajan y el costo de ejecución que
implica para el programa en sí. Todas a su vez tienen una serie de ventajas y desventajas,
siendo la más “costosa” de todas la búsqueda secuencial, debido a que su forma de trabajo
es buscar una referencia indicada registro por registro, uno a la vez como si examináramos
una serie de filas una por una hasta encontrar lo que buscamos. Sin embargo, es esta última,
la más sencilla de implementar y la que menos requerimientos tiene.
Su funcionamiento se explica mediante el siguiente algoritmo:
Consideremos que tenemos un vector, el cual está lleno de códigos numéricos de productos
de un supermercado y necesitamos buscar un producto en particular. Al ingresar el código a
buscar y decirle al programa que lo ubique en tal vector, operaría de la siguiente manera:
1. Va a la posición 1.
2. Compara el valor de esa posición con el ingresado a buscar.
3. Si son iguales lanza un mensaje o guarda la posición para futuras referencias.
4. De lo contrario pasa a la posición siguiente.
5. Repite pasos 2,3,4.
Como podemos apreciar, es un funcionamiento simple y básico, pero que funciona. El gran
problema radica cuando estamos operando con una cantidad masiva de datos, ya que los
accesos a memoria serían demasiados y el costo de ejecución (algo que los programadores
siempre deben tener en cuenta) sería alto.
Adicionalmente es bueno añadir que ese ejemplo referencia a un escenario ideal donde los
códigos no están repetidos. En caso de que lo estuviesen, deberíamos avisar en cada
posición que se encuentre una coincidencia.
Veamos un ejemplo de búsqueda secuencial:
Ejemplo: Llenar un vector de tamaño 5 con números y luego buscar algún valor y mostrar
por pantalla la posición en la que se encuentra:
#include <stdio.h>
#include <conio.h>
int main()
{
int arreglo[5],i,valor,x;
/* Declaramos las siguientes variables:
arreglo = Un vector de 5 posiciones donde tendremos los valores.

i = Variable para recorrer el vector.
valor = Variable para guardar el valor a buscar
x = Bandera que utilizamos para marcar que hayan valores.
*/
x=0; // Dejamos como 0 a x, lo que significa que no se han encontrado
coincidencias
printf (“Ingrese valores para llenar el vector:\n”);
// Mostramos un mensaje e introducimos valores al vector
for (i=0; i< 5; i++)
scanf(“%d”,&arreglo[i]);
// Solicitamos que se ingrese un valor a buscar

printf(“\nIngrese un valor a buscar: “);
scanf(“%d”,&valor);
/* Recorremos el vector y vamos comparando las posiciones con el valor a

buscar,
si hay una coincidencia, mostramos la posición por pantalla y marcamos la
variable
x con un 1 para indicar que se encontro valor */
for (i=0; i < 5; i++)
if (arreglo[i] == valor)
{
printf(“\nEl valor se encuentra en la posicion %d”,i);
x=1;
}
if(x==0)
printf(“\nNo se encontraron coincidencias”);
getch();
}
3.- Funciones
En la Parte 6 de esta saga, veíamos en una primera instancia lo que eran las funciones
cuando hablabamos de pseudo-código. Los conceptos son exactamente los mismos, así
como la forma de funcionamiento y operación de la función en sí, es decir:
tipo nombre_funcion(valor 1, valor 2… valor n)
{
operación 1;
operación 2;
.
.
operación n;
retorno de valor;
}
Veamos un ejemplo para dejar todo más claro:

Ejemplo: Determinar el mayor entre 2 números mediante el uso de una función:
#include <stdio.h>
#include <conio.h>
int numero_mayor(int valor1, int valor2); // Declaramos inicialmente la función

int main()
{
int num1, num2, mayor; //Declaramos las variables que utilizaremos
// Pedimos que se ingresen los numeros

printf(“\nIngrese Numero 1: “);
scanf(“%d”,&num1);
printf(“\nIngrese Numero 2: “);
scanf(“%d”,&num2);
// A mayor le asignaremos el resultado de la función

mayor=numero_mayor(num1,num2);
// Mostramos el resultado por pantalla

printf(“\nEl numero mayor es: %d”,mayor);
getch();
}
int numero_mayor(int valor1, int valor2) // Recibimos los valores
{
// Comparamos cual es mayor y lo retornamos
if(valor1>valor2)
return valor1;
else
return valor2;
}
4.- Añadiendo un menú al terminal de venta

Siguiendo con nuestro clásico ejemplo del terminal de ventas, si recordamos, la última vez
habíamos dejado nuestro ejemplo adaptado para poder realizar más de una venta y vender
en cada una de ellas más de un producto.
Bueno, el trabajo que realizaremos hoy será confeccionar un menú para que la aplicación
sea más completa y la función de ventas solo sea una parte de ese menú.
Como recordaremos, al final del ejemplo anterior, teníamos el siguiente código:
#include <stdlib.h>
#include <stdio.h>
#include <conio.h> /* Incluimos las librerías */
usaremos en el proceso */
int ok=1; /* Adicionalmente declaramos una variable ok, que nos servirá de
bandera para un ciclo que usaremos */
int opcion=1; /* Declaramos una variable opcion, que regulara si queremos hacer
más de una venta */
int main()
{
while(opcion==1)
{
while(codigo!=4) /* Definimos un ciclo que se ejecute siempre que el usuario no
presione la tecla para finalizar la venta */
{
printf(“\t Lista de productos\n”); /* Listamos los productos */
printf(“\nPara cerrar la venta, presione 4″); /* Añadimos la opción para cerrar la
venta */
printf(“\nIngrese el codigo del producto que desea llevar: “); /* Pedimos el código
del producto */
scanf(“%d”,&codigo); /* Leemos el código del producto */
if(codigo==4) /* Si el código es igual a 4, significa que la venta está finalizada, así
que cerramos el proceso de venta */
break;
printf(“\nIngrese la cantidad que desea llevar: “); /* Pedimos la cantidad */
if(codigo==1) /* Igualamos el código para asignar el precio */

valor=100;
if(codigo==2)
valor=350;
if(codigo==3)
valor=200;
total=total+(valor*cantidad); /* A total le asignamos, el total acumulado hasta

ahora, más el nuevo valor y nueva cantidad, multiplicados entre sí */
}
printf(“\nEl total es de: %d”,total); /* Saliendo de la venta, indicamos el total */
while(ok==1) /* Declaramos un ciclo con la variable ok, para el proceso de pago y
vuelto, así se ejecutará hasta que se pague la cantidad correcta */
{
if(pago<total) /* Si el pago es inferior al total, mostramos un mensaje de error */
else /* De lo contrario, cambiamos el valor de ok para romper el ciclo y mostramos
los mensajes de vuelto */
{
ok=0;
vuelto=pago-total;
}
}
printf(“\n¿Desea hacer otra venta? (1=Si , 0=No): “); /* Preguntamos si desea

hacer otra venta */
scanf(“%d,”,&opcion); /* Leemos la respuesta */
}
printf(“\nVenta finalizada”); /* Mensaje final */
getch(); /* Programa en pausa hasta pulsar una tecla */
}
Todo aquel código se refiere a lo que nombraríamos como “módulo de ventas”, que es la
funcionalidad principal del programa. Para confeccionar un menú, algo muy conveniente es
hacer uso de un ciclo tipo do-while y un switch, de la siguiente forma, utilizando una nueva
variable llamada menu para recoger la opción elegida, nuestro programa quedaría así:
llamado a librerías
declaración de variables
inicio de función main
do
{
printf(“1.- Módulo de ventas\n”);
printf(“2.- Administrar productos\n”);
printf(“3.- Administrar clientes\n”);
printf(“4.- Cerrar sistema\n”);
printf(“Ingrese opción: “);
scanf(“%d”,&menu);
switch(menu)
{
case 1: Aquí insertaríamos nuestro código anterior del módulo de ventas
break;
case 2: Por ahora en blanco, pero iría el código para administrar los productos
break;
case 3: Por ahora en blanco, pero iría el código para administrar los clientes
break;
case 4: break;
}
}while(menu!=4);
fin de función main
Con ese código, que dejaríamos al principio de nuestro programa, insertando el código
anterior en el caso 1 del switch, le diríamos al menú que se ejecutase hasta que se
seleccione la opción 4, que es cerrar sistema.
No es un código difícil de implementar, solo debemos fijarnos en el orden y no tendremos
problemas.
Y eso sería en la edición de hoy de Como aprender a programar y no morir en el intento. En
el próximo número cubriremos:
1. Paso de parámetros por valor y por referencia.
2. Estructuras.
3. Recursividad.

Manual

Загружено:

Сведения о документе

Оригинальное название

Авторское право

Доступные форматы

Поделиться этим документом

Поделиться или встроить документ

Параметры публикации

Этот документ был вам полезен?

Это неприемлемый материал?

Авторское право:

Доступные форматы

Manual

Загружено:

Авторское право:

Доступные форматы

Cómo aprender a programar y no morir en

2.- Introducción al Pseudo-Código

3.- Haciendo nuestro primer programa

/* Establecemos el inicio del programa */

/* Definimos la función “Principal” que es donde irá el cuerpo del programa.

mostrar “Hola Mundo”;

/* Utilizamos la sentencia “mostrar” para enviar un mensaje que se

Cómo aprender a programar y no morir en

1.- Definición de variables

/* Establecemos el inicio del programa */

Letra mensaje=”Hola mundo”;

/* A continuación definimos una variable de tipo “Letra”, de

/* Definimos la función “Principal” que es donde irá el cuerpo del

/* Utilizamos la sentencia “mostrar” para enviar un mensaje que se

Como podemos ver, en este ejemplo hemos definido una variable de

/* Establecemos el inicio del programa */

/* Definimos la función “Principal” que es donde irá el cuerpo del

/* Asignamos el valor “Hola mundo” a la variable mensaje y

/* Utilizamos la sentencia “mostrar” para enviar un mensaje que se

Esos son los pasos fundamentales para ir trabajando con variables.

2.- Leyendo datos desde teclado

/* Establecemos el inicio del programa */

/* A continuación definimos una variable de tipo “Letra”, de

/* Definimos la función “Principal” que es donde irá el cuerpo del

mostrar(“Ingrese un mensaje para mostrar: “);

/* Utilizamos la función mostrar para desplegar un mensaje por

/* Utilizamos la sentencia “mostrar” para enviar un mensaje que se

Con esto podemos recibir toda la infromación que necesitemos por

3.- Operaciones matemáticas

/* Establecemos el inicio del programa */

/* Definimos la función “Principal” que es donde irá el cuerpo del

mostrar(“Ingrese su edad: “);

/* Utilizamos la función mostrar para desplegar un mensaje por

/* En la variable resultado ahora almacenamos lo que nos dará el

mostrar (“Su edad en 10 años sera: %numero”,resultado);

/* Utilizamos la sentencia “mostrar” para enviar un mensaje que se

De esta forma desplegaremos un resultado de operar con un dato

4.- Iteraciones condicionales

Si (edad cumple una condición)

Veamos un ejemplo práctico sobre el uso de estas iteraciones condicionales, basándonos en

/* Establecemos el inicio del programa */

/* A continuación definimos una variable de tipo “Numero”, de

/* Definimos la función “Principal” que es donde irá el cuerpo del

mostrar(“Ingrese su edad: “);

Si (edad > 18)

mostrar “Ud. es mayor de edad”;

mostrar “Ud. es menor de edad”;

/* Utilizamos la iteración condicional “Si” con la condición si la

Claramente el ejemplo anterior presenta una de las iteraciones

Cómo aprender a programar y no morir en

1.- Iteraciones condicionales múltiples y uso de más de

2.- Switch: Otra iteración condicional.

mostrar(“Seleccione una opción: \n”);

caso ‘1′: mostrar(“Ingrese el nombre del usuario: “);

caso ‘3′: mostrar(“Los usuarios son: “);

caso ‘defecto’: mostrar(“Seleccionó una opción no válida”);

3.- Ciclos o Búcles

Cómo aprender a programar y no morir en

Introducción a los arrays

Y si queremos leer el valor de un vector, lo hacemos de la misma forma. Por ejemplo, si

Si en vez de ingresar datos, quisiéramos leerlos, lo hacemos de la misma forma.

Damos inicio al programa

Declaramos el vector y la variable que utilizaremos como índice para recorrerlo.

total=valorcantidad; / Multiplicamos el valor por la cantidad para obtener el

total=total+(valorcantidad); / A total le asignamos, el total acumulado hasta