miércoles, 9 de mayo de 2018

Array II: Arreglos Multidimensionales


Hola estimados lectores ¿Qué les ha parecido el curso? Si tienen oportunidad comenten acerca de su experiencia con é, así como también si tienen alguna duda. Con gusto les apoyaré. Ahora bien, continuemos con el siguiente capítulo. En el artículo anterior se dio inicio a las estructuras de arreglos con el tema Array I: Arreglos Unidimensionales, se le ha llamado unidimensionales precisamente por eso: Se expanden en una sóla dimensión, es decir, si indicamos el tamaño del arreglo ésta tendrá n cantidad de posiciones dirigidos en una misma dirección.

Todo esta bien, existen muchas cosas que pueden modelarse mediante un simple arreglo, pero en ocasiones requeriremos más de una dimensión para almacenar datos con características similares; en estos casos usaremos arreglos de más de una dimensión: Arreglos Multidimensionales.

Arreglos Multidimensionales

Cuando hablamos de arreglos multimendionales se hace referencia a cualquier array cuya dimensión es mayor a uno. Sin embargo, para fines prácticos y por estar más cercano a ejemplos cotidianos, estudiaremos arreglos de dos dimensiones, los cuales también pueden ser llamados Vectores.

Los vectores son arreglos de dos dimensiones (bidimensionales) cuya referencia a las posiciones se hacen a través de una dirección horizontal (columnas) y otra vertical (filas). Su sintaxis es la siguiente:

[tipo de dato] nombre_del_arreglo [tamaño_fila][tamaño_columna] (= {dato1, dato2,...,datoNxM} valor (opcional));

La sintaxis es similar al arreglo unidimensional con la salvedad que se debe indicar no sólo un tamaño sino dos: Uno para la fila y otro para la columna; adicionalmente si se inicializará con valores algunos valores estos se deben colocar unos tras otro (separados por coma). Un vector se representa gráficamente así:

Para asignar o extraer una datos dentro de un vector es necesario indicar tanto su fila como su columna. De esta maneras nos ubicamos en la posición deseada y manipulamos el dato. Es mejor que veamos un caso para entender mejor esta estructura:

#include <stdlib.h>
#include <iostream>
using namespace std;

int main (){
   float vector [2][2] = {2, 3, 4, 5};
   vector[0][1] = 5;

   for (int i = 0; i < 2; i++){
      for (int j = 0; j < 2; j++){
         cout << "-" << vector [i][j];
      }
   }

   return 0;
} 

En el ejemplo anterior vemos los siguiente:
  • Declaración del vector con valores iniciales: Se ha creado una vector 2x2, cuyos valores iniciales son los descritos entre llaves.
  • Luego modifica un dato en la posición de la fila 0 y columna 1 vector[0][1] = 5. 
  • Para recorrer por completo un vector utilizaremos la estructura de control for anidado. Vean que encontramos dos for, el primero utiliza como índice la variable i y el más interno la variable j. El funcionamiento es el siguiente, primero se ejecuta en el primer for y se verifica si la condición se cumple; para la primera vez la variable i es igual a cero (i=0), por lo que sí se cumple, permitiendo que se ejecute el segundo for. Acá también se evalúa la condición de j < 2; lo que hará que se recorra el vector dejando fijo la fila en 0 y moviendo la columna. Una vez que se recorra por completo toda la columna se incrementa la fila (variable i) y la variable j es reinicializada en cero. Así ocurrirá hasta que se haya paseado por todo el vector.
  • Para este caso se recorre todo el vector para mostrar sus valores.
Creo que ahora podemos agregarle un poco de dificultad a esto (aunque no considero sea difícil si le agarras el ritmo). El enunciando es el siguiente: Realizar un programa que cree una matriz cuadrada de un tamaño definido por el usuario. Le solicite al mismo los valores que rellenará la matriz y por último se muestre los valores de la diagonal principal.
#include <stdlib.h>
#include <iostream>
using namespace std;

int main (){
   int tam;

   cout << "Ingrese el tamaña del vector: ";
   cin >> tam;
   float vector [tam][tam];

   //Insercción de los Datos
   for (int i = 0; i < tam; i++){
      for (int j = 0; j < tam; j++){
         cout<<"Ingrese un dato para la posición "<<i<<","<<j<<": ";
         cin >> vector [i][j];
      }
   }
   cout << "Los valores de la Diagonal Principal de la matriz es "<<endl;
   for (int i = 0; i < tam; i++){
      for (int j = 0; j < tam; j++){
         if (i == j){
            cout <<" | "<< vector[i][j];
         }
      }
   }

   return 0;
}

¿Les pareció complicado el ejercicio? Fíjense que aplicando un poco de lógica y lo que hemos visto hasta ahora los resolvemos. Qué tal si lo analizamos:
  • El ejercicio le pide al usuario que indique el tamaño de una matriz cuadrada, esto significa que tanto su fila como columna es del mismo tamaña; por ese motivo se le solicita la usuario que indique un solo dato para el tamaño, cuyo valor es guardado en la variable tam.
  • Esa variable es usada para declarar al array vector[tam][tam]. Se declaró float para dar libertad a ingresar números con decimales.
  • Luego se colocan los for anidados para solicitar al usuario los datos de serán asignados al vector.
  • Más adelante se utiliza la misma estructura de for anidados para recorrer el arreglo. Dentro de  esta estructura se insertó un if, esto es necesario para que se imprima solo los valores de la Diagonal Principal. La Diagonal de una matriz es aquella donde sus índices son iguales; esto es: Los índices de la fila y columna son iguales (i==j). Es por eso que con el if se condiciona que cuando esto ocurra se imprima el valor del vector.
Con respecto a vectores se pueden aplicar muchos otros ejercicios interesantes. Les aseguro que haré un Apéndice con varios ejercicios hechos. Ya damos por concluido este capítulo de arreglos, pero antes les quiero dejar las siguientes observaciones:
  • A pesar de haber estudiado como Arreglos Multidimensionales con vectores bidimensionales, es posible crear arreglos de multidimensiones. Hasta ahora no he conseguido límites para ello, claro siempre he creado arreglos cuyos dimensiones son razonables. Recuerda que las variables y arreglos utilizan tu memoria RAM como espacio de almacenamiento y éste componente físico sí es limitado.
  • Es casi como una fórmula fija que para recorrer un arreglo completo utilizar un for anidado. El nivel de anidación dependerá de la dimensión del arreglo. Es por ello que si tenemos un arreglo de una dimensión usamos una sola estructura for. Si es bidimensional utilizamos dos for y así sucesivamente.
  • Recomiendo utilizar siempre for para recorrer un arreglo. Note que se puede ajustar una estructura while para recorrer un arreglo. Pero lo más práctico es usar el for.
Espero les hayan gustado este capítulo. Nos vemos en la próxima.

domingo, 6 de mayo de 2018

Array I: Unidimensionales


Hola estimados lectores y seguidores de este curso básico de Programación; antes de dar inicio al tema que atenderá este capítulo estudiemos la siguiente situación: Supongamos que hacemos un programa que se encarga de solicitar las notas de un estudiante universitario durante un semestre para almacenarlas y luego obtener su promedio en ese período académico. Agreguemos, además, que la cantidad de cátedras cursadas por los estudiantes son las mismas (cuestión que sabemos, en la práctica, no es necesariamente cierto).
 
Lo primero que se nos ocurre es crear las variables; aquí nos encontramos que debemos crear una cierta cantidad de ellas, pero cuántas el enunciado no nos lo dice. Para no complicarnos tanto al principio digamos que son 7 calificaciones. Esto nos obliga a crear la misma cantidad de variables para solicitar la información al usuario, guardarlas y luego manipularlas con el objeto de obtener el promedio. Perfecto, hecho.

Ahora extendamos esa suposición a algo más real. Tenemos el mismo programa que realizar, pero ahora no conocemos cuantas calificaciones ingresará el usuario y en vez del registro de un semestre se requiere de todas las cátedras que ha cursado durante la carrera; lo que nos obliga a crear n cantidad de variables (las cuáles no sabemos).

Si de por sí tener 7 variables de la mismas característica (notas) es impráctico y engorroso, lo es más si se deben crear 100 -y quizás me quede corto- para almacenar una cantidad de datos que desconocemos (imagínense como quedará la declaración de variables de este programa).

Arreglos Unidimensionales

Para estos casos existe una estructura de datos se ajusta perfectamente, estos son los Arreglos (Arrays en inglés). Los arreglos son estructuras de almancenamiento de datos similares a las variables que permiten reunir en ella varios datos de la mismas características. Por ejemplo, en el caso anterior que tenemos 7 calificaciones, en vez de crear siete variables (posiblemente nota1, nota2, ..., nota7) crearemos un arreglo llamado notas con siete posiciones de memorias. ¿Esto parece confuso? Veamos gráficamente su estructura para comprenderlo mejor.


 En la imagen anterior tenemos la estructura de un arreglo, cuyas particularidades son:
  • Es una Arreglo cuyo tamaño es 5, es decir, tiene 5 posiciones de memorias para almacenar esa cantidad de datos.
  • Poseen unos índice que sirven para ubicarnos dentro del arreglo y manipular un dato en específico.
  • En C++ los índices inician en 0, por eso razón es que vemos que para un arreglo de tamaño 5 los índices van de 0 a 4. Esto es muy importante tenerlo presente ya que si lo obviamos más adelante puede darnos un dolor de cabeza al momento de recorrer dichos arreglos.
Si lo vemos de otra forma, esta estructura es como cuando hacemos una cola para comprar. Todos tenemos una posición (índices) y en cada posición hay una persona cuya información es diferente (dato), pero el objeto a evaluar son lo mismo: personas (a menos que pongas a tu mascota hacer cola).

Bien, ya conocemos su estructura, ahora cómo la usamos. La forma de declarar un arreglo es de la siguiente forma:

[tipo de dato] nombre_del_arreglo [tamaño del arreglo] (= {dato1, dato2,...,datoN} valor (opcional));

Estudiemos esta sintáxis: 
  • Al igual que las variables, en los arreglos hay que definir el tipo de dato (int, float, char) y el identificador que tendrá (nombre del arreglo).
  • Se debe indicar el tamaño del arreglo, esto es, decir cuántos datos almacenará. En C++ es obligatorio que al momento de declarar el arreglo se indique su tamaño. En otros lenguajes como Python se puede dejar en blanco y luego se le dice que tamaño será. 
  • Como opcional se puede inicializar la variable indicando entre llaves { } los datos que tendrá. Lo común es que no se inicialice y carguen los datos con valores que se generan dentro del programa.
Ahora creo que estamos listo para ver un pequeño ejemplo:
 
#include <stdlib.h>
#include <iostream>
using namespace std;

int main (){
   int arreglo [3] = {1, 8, 10};

   arreglo [2] = 4;

   cout << "Ingrese un numero para modificar el valor del arreglo en la posicion 0";
   cin >> arreglo[0];
   cout << "El valor del arreglo en la posicion 0 es: " << arreglo [0];

   return 0;
} 

Analicemos este ejemplo:
  • Se crea un arreglo tipo entero de tres posiciones y de inicializa con tres valores. Fíjense que la sintaxis corresponde a la propuesta de arriba.
  • En la siguiente línea se cambia el valor del arreglo en la posición 2, es decir en valor 10 cambia por 4. Esta es la manera en la que se asigna un dato.
  • En las dos siguientes instrucciones se muestra un texto solicitando un nuevo dato para el arreglo en la posición 0 y con cin se captura por teclado y asigna a dicho arreglo en la posición 0 (cin >>arreglo [0]).
  • Posteriormente se muestra dato del arreglo en la posición 0.
En el ejemplo anterior vimos, inicialización de variable con valores iniciales; inserción de datos en un arreglo, tanto por un valor asignado como por captura por teclado, y muestra de un dato. Fíjense también que para indicar la posición en un arreglo colocamos un número que corresponde al índice. También es posible indicar la posición por asociación, esto es indicar a través de una variable el índice. Veamos de qué hablo.
#include <stdlib.h>
#include <iostream>
using namespace std;

int main (){
   int arreglo [3] = {1, 8, 10};
   int i = 2; j = 0;

   arreglo [i] = 4;

   cout << "Ingrese un numero para modificar el valor del arreglo en la posicion 0";
   cin >> arreglo[j];
   cout << "El valor del arreglo en la posicion 0 es: " << arreglo [j];

   return 0;
} 

Este ejercicio es similar al anterior, con la diferencia que ahora se indica la posición de los índices mediante la asociación de las variables i y j. Listo, qué les parece si complicamos un poco más los ejercicios para esta vez utilizar la sentencia de repetición for en el recorrido de los arreglos.

Propongo hacer el programa del enunciado con la cual iniciamos este artículo. Vamos a solicitar al usuario las n cantidad de calificaciones y obtener su promedio. Previamente se le debe pedir al estudiante que nos indique cuántas notas ingresará. Iniciemos:

#include <stdlib.h>
#include <iostream>
using namespace std;

int main (){
   int tam, suma = 0, prom;

   cout << "Indique la cantidad de notas que ingresará ";
   cin >> tam;

   int notas [tam];

   //Carga de Datos
   for (int i = 0; i < tam; i++){
      cout << "Ingrese una calificación :";
      cin >> notas[i];
   }
   //Calculo del Promedio
   for (int i = 0; i < tam; i++){
      suma = suma + notas[i];
   }
   prom = suma / tam;
   cout << "Tu promedio es: " << prom;

   return 0;
} 

Veamos:
  • En esta ocasión antes de crear el arreglo inicializamos tres variables tam, suma y prom. La variable tam la usaremos para capturar la cantidad de notas que ingresará el estudiante, suma para almacenar la sumatoria de la nota y prom para el promedio.
  • Una vez que el usuario indica cuantas calificaciones ingresará se crea el arreglo a través de la asociación con la variable tam. 
  • Posteriormente se utiliza la estructura de repertición for para recorrer el arreglo y asignar las notas que el usuario ingresará por teclado. En el for indicamos la variable que será de cambio la i la que, a su vez, será la asociación del índice del arreglo; por ejemplo, cuando i = 0, se apuntará al arreglo en la posición 0 (notas[i]). En el mismo for se dice que se repetirá la acción mientras la condición de i < tam se cumpla y luego i aumentará en uno (i++) al llegar al final del for.
  • Una configuración similar del for se utiliza para obtener el promedio. Se recorre el arreglo y en cada posición se realiza una sumatoria (suma = suma + notas[i]). Nota: Es importante que para las sumatoria se inicialice la variable que acumulará el dato en 0. En este caso, la variable suma se inicializó así suma = 0.
  • Por último, fuera del for, se obtiene el promedio y se muestra el dato.
Este ejercicio, apesar de ser sencillo, es suficiente para entender cómo funcionan los arreglos y cómo se recorren para manipular sus datos. Es requerido que lo analicen y si tienen algún inconveniente no duden en comentar.
Con esto concluimos esta primera parte de arreglos. Como su título lo indica son arreglos unidimensionales, es decir de una dimensión. En el siguiente capítulo estudiaremos los arreglos multidimensionales, también conocidos como vectores.

martes, 1 de mayo de 2018

Estructura de Repetición II: FOR



Continuamos con las Estructuras de Repetición; en esta oportunidad con el FOR. En el capítulo anterior estudiamos el WHILE y DO WHILE. ¿Por qué separar el FOR de las dos anteriores? Considero que, a pesar de ser estructuras usadas para la repetición, la forma y el objeto en la que se usa, son diferentes.

FOR

La sentencia FOR es usado normalmente para recorrer estructura como arreglos (el cual veremos en el capítulo siguiente), cuya características principales son:
  • Usa un mecanismo de iniciación de variable, evaluación de condición y razón de cambio de la variable dentro de una misma línea de instrucción. 
  • La condición que se aplica sobre la variable evalúa que ésta se encuentre dentro de un rango.
  • La variable tiene una razón de cambio fija de incremento o reducción.
Para comprenderlo mejor veamos su sintaxis y ejemplo de su aplicación.

for (iniciacion de variable; condición; razón de cambio){
   instrucciones;
   ...
}

#include <stdlib.h>
#include <iostream>
using namespace std;

int main (){
   int num;
   cout << "Indique de cuál número desea saber su tabla de multiplicación" << endl;
   cin >> num;
   for (int i=0; i < 11; i++) {
      cout << i << "x" << num << " = " << i*num << endl;
   }
   return 0;
} 

He tomado un ejercicio visto en el capítulo anterior por la estructura DO WHILE para que vean la diferencia entre ambas. Quizás comenten que me estoy quedando sin creatividad, esto no es precisamente cierto; lo que ocurre es que quiero que noten el funcionamiento del FOR para, posteriormente ver su potencialidad cuando trabajemos con los arreglos. Ahora, analizando el programa notemos:
  • En una misma línea de instrucción se inicializa la variable, evalúa la condición y se indica la forma que cambiará la variable evaluada, todas estas separadas por punto y coma (;).
  • Lo novedoso, quizá, sea la forma que se presenta la razón de cambio i++ esto indica que la variable i incrementará de uno en uno, lo que sustituye en el caso anterior a i = i + 1. En el caso que se requiere disminuir se utiliza i--.
El FOR es una herramienta muy útil y es muy usada en la exploración de estructuras que contienen índices que indican una posición, tales como los arreglos. De hecho, mientras vayamos agregando mas cursos de programación de nivel avanzado, es muy probables que usemos más esta sentencia de repetición que las otras anteriores.

Con esto concluimos este capítulo, pero antes voy a dejarles unos ejercicios para que practiquen las estructuras de repetición. Estas son las siguientes:
  • Con WHILE: Realice un programa que solicite al usuario un número entre el 1 al 10 repetidamente hasta que ingrese el número 7.
  • Con DO WHILE: Adapte el programa del área de un triángulo visto anteriormente dándole la oportunidad al usuario de elegir si desea repetir la operación.
  • Con FOR: Repita el ejercicio mostrado en este artículo, pero ahora la razón de cambio de la variable i es de dos en dos.
Espero les haya gustado este capítulo. Nos vemos pronto.

Estructura de Repetición I: WHILE Y DO WHILE



En el capítulo anterior agregamos un nuevo valor a nuestros programas: La capacidad de tomar decisión en función a una información que cambia durante el proceso. La estructuras de control nos permiten dirigir el flujo de las instrucciones dependiendo de una condición evaluada.

Aunque esto es funcional -de hecho como vimos anteriormente se logró un programa que cumple un objetivo- aun queda ciertas limitaciones que podemos atender, tal es el caso de si deseáramos repetir cierta tarea o líneas de códigos mientras una condición se cumpla. Para estas situaciones nos valemos de las estructuras de repetición.


WHILE

La primera estructura de repetición que veremos es el WHILE. Para estudiar su funcionamiento comencemos por conocer su sintaxis: 

while (condición){
   instrucciones;
   ...
}

Ahora, comencemos con el análisis de la estructura while:
  • Para iniciar una estructura while primero se ha evaluar una condición y si ésta se cumple se ejecuta el código que se encuentra entre llaves {}.
  • Si queremos que las instrucciones que se encuentren dentro del while se ejecuten, al menos una vez, debemos garantizar que la condición se cumpla, de lo contrario no se ejecutarán.
  • Es indispensable que la variable a evaluar dentro de la condición pueda ser cambiada dentro del código inmerso en el while, ya que si no se hace nunca se romperá el bucle de repetición haciendo que nuestro programa se ejecute infinitamente (claro, al menos que lo cerremos desde el sistema operativo).
  • Al llegar al final de la estructura (cuando se encuentra con el final de la llave }) se retorna al inicio para evaluar nuevamente la condición.
Para comprenderlo mejor hagamos un ejercicio: Se requiere un programa que muestre un mensaje repetitivamente hasta que decidamos no volver a verlo.

#include <stdlib.h>
#include <iostream>
using namespace std;

int main (){
   char opcion = 's';

   while (opcion == 's'){
      cout << "Se estas convirtiendo en un buen programador" << endl;
      cout << "Quieres volver a ver el mensaje? s/n" << endl;
      cin >> opcion;
   }
   return 0;

} 

Veamos con detalle el ejercicio anterior:

  • Se ha creado una variable llamada opcion cuyo valor inicial es el carácter s (en minúscula).
  • En la estructura de repetición while se tiene una condición que evalúa si la variable opcion es igual a s (en minúscula) entonces se ejecutará el código dentro de la estructura y, por ende, se mostrará el mensaje.
  • Posteriormente se muestra un texto indicándole al usuario si desea volver a ver el mensaje confirmándolo ingresado la letra s, o n en caso de no querer volver a verlo.
  • Noten: lo que ingresa el usuario se guarda en la variable opcion. A esto es lo que me refiero cuando indico que la variable que se evalúa en la condición debe poder cambiarse dentro de la misma estructura, ya que de no hacerlo opcion siempre será igual a s, por lo que el bucle se repetirá eternamente. Al volverse a evaluar la condición ahora se revisará si el usuario tecleo s o n; si es s se repite el mensaje y si es n se continua con las instrucciones debajo de la estructura de repetición, que en este caso es terminar el programa.
  • Otra acotación, si por descuido o intención el usuario ingresa la S (mayúscula), al evaluar la condición ésta no se cumplirá, ya que se esta preguntando si opcion == 's', la cual esta en minúscula, para que se puedan evaluar ambas posibilidades conviene agregar lo siguiente:
    • opcion == 's' || opcion == 'S'; las dos barras es un operador OR Lógico y lo que esta indicando que evalúe si opcion es s o S. Si cumple alguna de las dos se ingresará al bloque de código del WHILE.
  • Veamos también la variable opcion se inicializó con s, esto fue así para garantizar que ingresará al código al menos una vez. Supongamos por un momento que no se hubiese inicializado la variable; al llegar a la condición y preguntar si opcion == 's' se obtendrá como resultado que no se cumple la condición por lo tanto no se ejecutará las instrucciones dentro del WHILE. Para confirmar eso, prueben el código quitando la inicialización, ejecútenlo y vean ocurre.


DO WHILE

La estructura WHILE obliga a evaluar la condición al inicio, por lo que si queremos que el código se ejecute al menos una vez debemos garantizar que la condición se cumpla, tal como lo vimos en el apartado anterior. En C++ se cuenta con una estructura de repetición similar al WHILE original, pero que evalúa la condición al final de la estructura, lo que permite que las instrucciones que se encuentran dentro de él se ejecuten una primera vez. La sintaxis del DO WHILE es la siguiente:

do {
   instrucciones;
   ...
}while (condición);

Aquí podemos notar algunos cambios algo evidentes:
  • El primer cambio que se observa, en sintonía con su propuesta, es que la condición se esta evaluando al final de la estructura, por lo que el bloque de instrucciones dentro del DO WHILE se ejecutarán al menos una vez.
  • La instrucción while (condicion); debe terminar con un punto y coma (;) de lo contrario habrá un error en la sintaxis.
Hagamos un ejercicio para ver el funcionamiento de esta estructura:

#include <stdlib.h>
#include <iostream>
using namespace std;

int main (){
   int i = 0, num;

   cout << "Indique de cuál número desea saber su tabla de multiplicación" << endl;
   cin >> num;
   do {
      cout << i << "x" << num << " = " << i*num << endl;
      i = i+1;
   } while (i < 11);
   return 0;

} 

El ejercicio anterior se diseño para que muestre la tabla de multiplicar de un número que el usuario ingrese. Hagamos su análisis:
  • Se crean dos variables i que funcionará como multiplicador el cual se incrementará después de cada operación y num que es el número al que se le hará la multiplicación y será indicado por el usuario. 
  • Luego se le indica al usuario que ingrese el número al cual se le generará la tabla de multiplicar. El dato se guardará en la variable num.
  • Se entra en la estructura DO WHILE y se muestra la multiplicación de la variable i*num. Esta línea del cout posee mucha concatenanción, esto se hizo para darle un mejor formato de vista.
  • Luego se incrementa el valor de la variable i en uno (es una forma de hacerlo, más adelante mostraré otra forma de incrementar una variable).
  • Y por último se evalúa la condición, la cual verá si i es menos que 11, de ser así se vuelve a repetir el código, de lo contrario se termina la estructura de repetición.

Fíjense que su objetivo son similares lo que cambia es el momento en la que se evalúa la condición, lo cual trae como consecuencia que en éste último se garantice una pasada por las instrucciones. 


Bien, esto es todo con respecto a estas dos estructura, pero antes de cerrar este artículo quiero mostrarle un ejercicio con la que se unirá ambas estructura para que noten el potencial que se puede lograr con ellas: Este ejercicio combinará ambos ejercicios anteriores, es decir generará la tabla de multiplicación de un número ingresado por el usuario, una vez mostrada se le preguntará si quiere repetir la operación.
#include <stdlib.h>
#include <iostream>
using namespace std;

int main (){
   char opcion = 's';
   int i = 0, num;

   while (opcion == 's' || opcion =='S'){
     cout << "Indique de cuál número desea saber su tabla de multiplicación" << endl;
     cin >> num;
     do {
        cout << i << "x" << num << " = " << i*num << endl;
        i = i+1;
     } while (i < 11);
     cout << "Desea repetir la operación? s/n ";
     cin >> opcion;
     i = 0;
   }
   return 0;
} 

Espero les haya gustado este capítulo, si tienen alguna duda comentén, con gusto les responderá. Hasta pronto.

domingo, 29 de abril de 2018

Operadores


Cuando hacemos un cálculo matemática normalmente utilizamos ciertos símbolos para indicar que tipo de operación es la que se ha de realizar, así encontramos que para sumar usamos el símbolo +, para restar -, y así sucesivamente. Pues resulta que en programación existe una bien definida cantidad de símbolos -las que de ahora en adelante llamaremos operadores- que nos permiten indicar que operación matemática, lógica, de comparación, entre otros, se han de realizar. En esta aportunidad se mostrarán los más utilizados en el lenguaje de programación C++. 

Operadores de Comparación 

Nombre del Operador Sintaxis
Menor que a < b
Menor o igual que a <= b
Mayor que a > b
Mayor o igual que a >= b
Diferente de a != b
Igual que a == b
Negación Lógica !a
AND Lógico a && b
OR Lógico a || b

Los operadores de comparación son utilizados para construir las condiciones en las estructuras de control y repetición if, while, do while y for.

Otros operadores

Nombre del Operador Sintaxis
Asignación Básica a = b
Llamada a función a()
Índice array a[b]
Indirección *a
Dirección de &a

Esta lista de operadores son utilizados en las intrucciones de operación del programa. Por ejemplo en la asignación de una valor a una variable, en la definición de arreglos y funciones, entre otros.

Nota: Me gustaría ofrecer una aclaratoría con respecto al operador de igualdad (=) ya que muchas veces los que se están iniciando en la programación tienden a tener confusión cuando lo utilizan para asignar o para comparar. Cuando se coloca una igualdad estas asignando un valor a una variable, ejemplo a = 3, esto quiere decir que a almacenará el valor 3. Por otro lado, cuando se coloca doble igualdad (==) estamos realizando una comparación, en otras palabras, si queremos verificar si a es igual a b se debe usar la doble igualdad.

Estructuras de Control


Nuevamente bienvenidos a este curso de Programación Básica. En esta oportunidad le presentaremos uno de los capítulos más relevante: Las estructuras de control. Hasta ahora nuestros programas han sido muy "lineal", esto es, desde que se inicia hasta que finaliza no se ha tomado ningun tipo de decisión, únicamente se han ejecutado instrucciones netamente operativas. 

Permítame explicarme mejor: En el ejercicio de suma del capítulo anterior se solicita por teclado los valores del primer y segundo número, estos se adiccionan y, posteriormente, se muestra el resultado. En ningún momento se ha tomado una decisión al respecto, como por ejemplo, realizar la suma si el primer número es mayor que el segundo.


Sentencia IF - ELSE

Cuando es requerido tomar decisiones dentro del programa hacemos uso de las sentencias de control: IF - ELSE. La estructura es la siguiente:

if (condición){
   // instrucciones;
   // ...;
} else {
   // instrucciones;
   // ....
}

¿Cómo funciona esto? Pues, primero se evalúa la condición del if si esta se cumple se ejecutarán las instrucciones que se encuentran debajo de ella, en caso contrario se ejecutarán las instrucciones debajo del else (el else es opcional, no es obligatorio incluirlo). Note que el if se abre y se cierra con llaves { } y dentro de ellas las instrucciones que se ejecutarán. Lo mismo ocurre con el else. 

Veamos un ejemplo para comprender mejor lo anterior: Realicemos un programa que muestre en pantalla un mensaje cuando una persona posea una edad mayor a 17 años.

#include <stdlib.h>
#include <iostream>
using namespace std;

int main(){
   int edad;
   cout << "Indique su edad: ";
   cin >> edad;
   if (edad > 17){
      cout << "Usted es mayor de edad";
   }
   return 0;
}

Al ejecutarse este programa se solicitará al usuario que ingrese su edad. Si la edad es mayor a 17 se ejecutará la instrucción cout << "Usted es mayor de edad", en caso contrario se terminará el programa. Ahora, si no queremos que termine el programa al no cumplirse la condición sino que muestre otro mensaje nos apoyaremos con la sentencia else de esta forma:

#include <stdlib.h>
#include <iostream>
using namespace std;

int main(){
   int edad;
   cout << "Indique su edad: ";
   cin >> edad;
   if (edad > 17){
      cout << "Usted es mayor de edad";
   } else {
      cout << "Usted es menor de edad";
   }
   return 0;
}

Ahora, en el caso de no cumplirse la condición del if se ejecutará las instrucciones que están enmarcadas en el else. Para el else no es requisito evaluar una condición ya que, como se mencionó anteriormente, esta opción que se ejecutará cuando no se cumpla el if. 

Nota: Dentro de la condición se coloca operadores que son las que permiten evaluar la condición, estos operadores pueden verlos en el Apendice: Operadores.

En los casos anteriores sólo se evaluaron dos condiciones, si la edad es mayor a 17 años o, de lo contrario,  que no lo sea. Pero si deseamos evaluar más de dos condiciones lo podemos lograr concantenando un if después de un else (en algunos lenguaje de programación es conocido como elseif). Como ejemplo veamos el siguiente código: 

#include <stdlib.h>
#include <iostream>
using namespace std;

int main(){
   int edad;
   cout << "Indique su edad: ";
   cin >> edad;
   if (edad > 18){
      cout << "Usted es mayor de edad";
   } else if (edad == 18){
      cout << "Bienvenido a la mayoría de edad";
   } else {
      cout << "Usted es menor de edad";
   }
   return 0;
}

Vemos ahora que tenemos tres condiciones:
  1. Cuando la edad es mayor a 18 (edad > 18).
  2. Cuando la edad es igual a 18 (edad == 18).
  3. Cuando no es mayor ni igual a 18, es decir, cuando es menor a 18.
Con esta estructura podremos construir flujo de ejecución de programas tan complejas tales que nos permitan particularizar ciertas instrucciones para condiciones muy específicas. 

Para cerrar haremos un ejercicio del cual quedará de su parte su análisis, si tienen alguna duda comente y con gusto les apoyaré. El enunciado de la actividad es el siguiente: Realizar un programa que simule la ejecución de una calculadora que permita sumar, restar, multiplicar y dividir dos números, en la cual el usuario deberá seleccionar cual operación matemática quiere hacer.

#include <stdlib.h>
#include <iostream>
using namespace std;

int main (){
   int opcion;
   float num1, num2, resultado;

   cout << "Que operacion matematica desea realizar" << endl;
   cout << "1.- Suma" << endl;
   cout << "2.- Resta" << endl;
   cout << "3.- Multiplicacion" << endl;
   cout << "4.- Division" << endl;
   cout << "Seleccione una opcion --> ";
   cin >> opcion;

   cout << "Introduzca el numero 1 ";
   cin >> num1;
   cout << "Introduzca el numero 2 ";
   cin >> num2;

   if (opcion == 1){
      resultado = num1 + num2;
      cout << "El resultado es " << resultado;
   } else if (opcion == 2){
      resultado = num1 - num2;
      cout << "El resultado es " << resultado;
   } else if (opcion == 3){
      resultado = num1 * num2;
      cout << "El resultado es " << resultado;
   } else if (opcion == 4){
      resultado = num1 / num2;
      cout << "El resultado es " << resultado;
   } else {
      cout << "Opcion incorrecta";
   }
   return 0;
} 

sábado, 28 de abril de 2018

Programación Multimedia



Como parte de una actividad de la Cátedra Programación Multimedia, impartida en la Universidad Marítima del Caribe, se ofrece una serie de artículos cuyos autores son los integrantes de dicho curso. La intención de la misma es ofrecer un contenido relacionado a la multimedia y la influencia de la misma en la educación; así como servir de como medio de evaluación a su manera de desarrollar un artículo, evaluando su forma y fondo. 

Les pido sean muy receptivos con la información mostrada y, en sus comentarios, ofrezcan críticas constructivas para el mejoramiento de los autores. Espero disfruten la información mostrada.

Los temas son los siguientes:

Fijación del Conocimiento mediante las herramientas multimedias

Este artículo es autoría de Luis Cedeño y Carlos Ladera como parte de una actividad de la Cátedra Programación Multimedia. Se insta a los lectores a opinar acerca del contenido ofrecido en cuanto a forma y fondo, para maximizar la experiencia de los autores en la escritura de este tipo de documentos. Espero lo disfruten.


Fijación del Conocimiento mediante las 
Herramientas Multimedias


El Uso de las herramientas multimedia para el flujo del conocimiento es importante, ya que proporciona: la motivación, innovación, interactividad, e induce a la investigación, explorar y experimentar con el computador y a su vez amplia el conocimiento de una manera más práctica y divertida. Las herramientas multimedia pueden  realizar múltiples funciones en el proceso de transmitir conocimiento, por consiguiente puede ser un instrumento el uso del docente y el estudiante, donde puedan Interactuar con herramientas para aprender y experimentar proporcionando el estudiante un interés y una motivación correcta e innovadora, conllevando así al crecimiento del conocimiento e ir a la par con el avance de la tecnología y actualmente existe una gran variedad de programa de diferentes funciones como herramienta multimedia, que nos ofrecen mayor aporte para manejo de la información y ser distribuida de manera clara y eficaz, ya que al estudiante le parece muy atractivo manejar la información atreves de presentaciones, animaciones, videos, audios e imágenes.



Cada vez son más y mejores las herramientas de edición multimedia disponibles en el mercado. Sin embargo, el mayor problema está en la formación adecuada de los potenciales autores de trabajos multimedia educativos, que habitualmente son los propios docentes en vez de personal específicamente formado para tal trabajo. Se pretende con esta comunicación reflejar de forma esquemática, las líneas de acción principales de diseño y evaluación de un sistema instructivo multimedia.


En el caso de  la educación a distancia convencional la información se intercambia por medio de material escrito entre el tutor y los alumnos, quedando el contacto entre ellos reducido a unas escasas tutorías y, a veces, a llamadas telefónicas o el correo postal o el envío por fax. Sin embargo, a través de Internet, la formación a distancia alcanza una nueva dimensión al incorporar como estrategias de enseñanza las posibilidades que Internet ofrece. La educación a distancia se debe servir hoy en día de estos nuevos medios, como son las páginas Web, los sistemas multimedia, los libros interactivos, etc.


La implantación de las herramientas multimedia como instrumento docente ha proporcionado  al mundo de la enseñanza. Los métodos de enseñanza tradicionales, poco garantes de motivación para el alumno y acreedores de un gran esfuerzo de retención para asimilar los conceptos, vienen desde hace ya algún tiempo siendo sustituidos por el constructivismo, la investigación acción, las dinámicas de grupos y el aprendizaje por descubrimiento. Estas filosofías de la enseñanza aprendizaje están siendo reforzadas por la multimedia interactiva, que contribuye significativamente a la motivación del discente, la mejora del aprendizaje de forma constante y eficaz, el aumento de la retención y la reducción del tiempo de aprendizaje.


La multimedia y el docente
Debemos tomar en cuenta y aclarar que las herramientas multimedia no son en sí ningún sistema pedagógico, son únicamente una herramienta que se puede y se debe poner al servicio de la formación, ya que su utilización de forma adecuada puede reforzarla significativamente el desarrollo del aprendizaje. Por lo tanto, los actores fundamentales dentro de un sistema docente multimedia interactivo son: el discente como acreedor de la información y del conocimiento, el propio sistema, diseñado convenientemente para cumplir sus funciones, y el docente, como administrador del conocimiento y en su papel de generador de contenidos y orientación.

La función de las tecnologías telemáticas no es la de definir al profesorado sus intenciones educativas sino la de ayudarle a establecerlas y a lle­varlas a la práctica. La selección de los materiales y recursos debe responder a criterios que tengan en cuenta el contexto educativo, las características de los alumnos con los que se trabaja y, sobre todo, el que esté al servicio de esas intenciones. Hay que diferenciar entre los materiales curriculares para el pro­fesorado y para los alumnos. En relación a los primeros, han de servir para orientar al profesorado sobre los distintos aspectos que han de tenerse en cuenta en el proceso de enseñanza/aprendizaje. La mayor responsabilidad del profesorado en la determinación de las intenciones educativas y de las estrategias para llevarlas a cabo exige el que estos materiales sean orientativos y por ello diversos: que ofrezcan modelos distintos y perspectivas amplias, dentro de las cuales haya posibilidades distintas de concreción.
Por otra parte, el tratamiento didáctico-pedagógico de los temas desde el punto de vista del modelo constructivista incidirá positivamente, junto con los medios empleados, sobre los contenidos, contribuyendo así a un aprendizaje significativo y favoreciendo la formación continua. Para el constructivismo, adquirir conocimientos supone:
  •  encontrar sentido a la información que se almacena,
  • establecer relaciones entre lo que se aprende y el conocimiento previo,
  • reestructurar la información recibida.

La utilización de las nuevas tecnologías interactivas en la enseñanza, al igual que la de cualquier otro medio audiovisual, sirve al profesor para superar el modelo comunicativo unidireccional y no para reforzarlo. Podría darse la paradoja de estar preocupándonos por conseguir un máximo nivel de interacción entre los alumnos y los medios mientras descuidamos la propia interacción humana, la más importante y enriquecedora, de cuya calidad va a depender el que los alumnos aprendan a utilizar los medios para expresarse, y no se consideren únicamente como receptores de información.
Video de apoyo al artículo: