tag:blogger.com,1999:blog-86065511719600070782024-03-19T19:52:37.062-07:00Algoritmia: Programar es fácilEste Blog contiene los problemas típicos de programación con los que se encuentran los estudiantes de informática.MIPBhttp://www.blogger.com/profile/15144077089562468638noreply@blogger.comBlogger36125tag:blogger.com,1999:blog-8606551171960007078.post-60412336911792315592020-12-29T07:26:00.000-08:002020-12-29T07:26:10.958-08:00Cambio de base<p>Vimos en la explicación del operador <a href="http://ejemplosalgoritmos.blogspot.com/2015/10/operacion-residuo-mod.html" target="_blank">MOD </a>un ejemplo de hacer un cambio de base de un número decimal a un binario. En esta oportunidad lo que haremos es generalizar este ejemplo y hacer un programa en C++ que haga el cambio de base del decimal a uno cualquiera que introduzcamos por pantalla.</p><p>Un ejemplo de ejecución sería el siguiente:</p><p></p><div class="separator" style="clear: both; text-align: center;"><div class="separator" style="clear: both; text-align: center;"><a href="https://blogger.googleusercontent.com/img/b/R29vZ2xl/AVvXsEg9Ea0ksi0ylOWgrXtB_qUcYVh3URs3vanxu1IIbdUTMjoGknUKPqitYrzP8LnE_ULJXC99S4pIZy5_gzgB2dEVxj57_OiDCycP20OC85npL-q7xBHQP5KNk5SnHVzQEKN6uS2VMjX9jOI/" style="margin-left: 1em; margin-right: 1em;"><img alt="" data-original-height="144" data-original-width="497" height="93" src="https://blogger.googleusercontent.com/img/b/R29vZ2xl/AVvXsEg9Ea0ksi0ylOWgrXtB_qUcYVh3URs3vanxu1IIbdUTMjoGknUKPqitYrzP8LnE_ULJXC99S4pIZy5_gzgB2dEVxj57_OiDCycP20OC85npL-q7xBHQP5KNk5SnHVzQEKN6uS2VMjX9jOI/" width="320" /></a></div><br /></div><br />Lo que vemos en este ejercicio es el uso de:<p></p><p></p><ul style="text-align: left;"><li>El operador <b>MOD (%)</b></li><li>El iterador <b>do-while </b>y </li><li>El iterador <b>for con índice creciente y decreciente</b></li></ul><p></p><p>A continuación os dejo el código y podríamos pensar algunas variantes como la representación en base hexadecimal teniendo en cuenta las letras.</p><p><br /></p><p>int main(int argc, char** argv) {</p><p><span style="white-space: pre;"> </span>int base10;</p><p><span style="white-space: pre;"> </span>int baseN;</p><p><span style="white-space: pre;"> </span>char res[50]; <span style="color: #6aa84f;">//array que almacena los residuos según los va calculando</span></p><p><span style="white-space: pre;"> </span>int nRes = 0;</p><p><span style="white-space: pre;"> </span>char res2[50]; <span style="color: #6aa84f;">//array que almacena los residuos con la lectura inversa (resultado final)</span></p><p><span style="white-space: pre;"> </span></p><p><span style="white-space: pre;"> </span>printf("Ingresa un numero en base decimal:");</p><p><span style="white-space: pre;"> </span>scanf("%d", &base10);</p><p><span style="white-space: pre;"> </span></p><p><span style="white-space: pre;"> </span>printf("\nIngresa la base a la que quieres cambiar:");</p><p><span style="white-space: pre;"> </span>scanf("%d", &baseN);</p><p><span style="white-space: pre;"> </span></p><p><span style="white-space: pre;"> </span>int q = base10;</p><p><span style="white-space: pre;"> </span>int r = 0;</p><p><span style="white-space: pre;"> </span></p><p><span style="white-space: pre;"> </span><span style="color: #6aa84f;">//calcula residuos hasta que el cociente es 0</span></p><p><span style="white-space: pre;"> </span>do{</p><p><span style="white-space: pre;"> </span>r = q % baseN; <span style="color: #6aa84f;">//calcula residuo</span></p><p><span style="white-space: pre;"> </span>q = q / baseN; <span style="color: #6aa84f;">//recalcula la nueva "q" para la siguiente iteración</span></p><p><span style="white-space: pre;"> </span>res[nRes] = r; <span style="color: #6aa84f;">//concatena el residuo al resultado</span></p><p><span style="white-space: pre;"> </span>nRes++; <span style="color: #6aa84f;">//número de cifras del resultado</span></p><p><span style="white-space: pre;"> </span>}while(q > 0);</p><p><span style="white-space: pre;"> </span></p><p><br /></p><p><span style="white-space: pre;"> </span><span style="color: #6aa84f;">//invierte el resultado (la lectura de los residuos es invertida)</span></p><p><span style="white-space: pre;"> </span>for(int i = (nRes - 1); i >= 0; i--) res2[nRes - i - 1] = res[i];</p><p><span style="white-space: pre;"> </span></p><p><span style="white-space: pre;"> </span><span style="color: #6aa84f;">//imprime resultado en pantalla</span></p><p><span style="white-space: pre;"> </span>printf("\n%d en base %d es: ", base10, baseN);<span style="white-space: pre;"> </span></p><p><span style="white-space: pre;"> </span>for(int i = 0; i < nRes; i++) printf("%i", res2[i]);</p><p><span style="white-space: pre;"> </span></p><p><span style="white-space: pre;"> </span>return 0;</p><p>}</p>MIPBhttp://www.blogger.com/profile/15144077089562468638noreply@blogger.com0tag:blogger.com,1999:blog-8606551171960007078.post-27346886469427599282020-12-17T08:03:00.008-08:002020-12-21T08:05:54.358-08:00Subconjunto ordenado de array<p>El siguiente ejemplo pide ingresar una lista de números positivos y guardarlos en un array, para luego leerlos y copiar a otro array de forma ordenada sólo aquellos que son múltiplos de 5.</p><p>Un ejemplo de ejecución:</p><p></p><div class="separator" style="clear: both; text-align: center;"><a href="https://blogger.googleusercontent.com/img/b/R29vZ2xl/AVvXsEjAwIInFINLXFtmjE5hYyk0-YQlHwrrahvD4thrYWYDQU6HvIM6ODXZ6QcnFqvHHJa0_GOwervjnpHOo4Lqa4zWTOHvW9DoFu9xCah3e93uNIsxJVoGYjBvvKZIHgw3bcbwLOByqhFhPYU/" style="margin-left: 1em; margin-right: 1em;"><img alt="" data-original-height="295" data-original-width="539" height="175" src="https://blogger.googleusercontent.com/img/b/R29vZ2xl/AVvXsEjAwIInFINLXFtmjE5hYyk0-YQlHwrrahvD4thrYWYDQU6HvIM6ODXZ6QcnFqvHHJa0_GOwervjnpHOo4Lqa4zWTOHvW9DoFu9xCah3e93uNIsxJVoGYjBvvKZIHgw3bcbwLOByqhFhPYU/" width="320" /></a></div><br /><br /><p></p><p>¿Qué cambiarías en el programa para que extraiga los múltiplos de otro número?</p><p>¿Qué cambiarías para que el orden sea ascendente?</p><p>¿Qué otras variaciones añadirías al programa?</p><p><br /></p><p>#include <iostream></p><p>int main(int argc, char** argv) {</p><p><span style="white-space: pre;"> </span>int fin = 0;</p><p><span style="white-space: pre;"> </span>int numero;</p><p><span style="white-space: pre;"> </span>int listaNumeros[20];</p><p><span style="white-space: pre;"> </span>int totalNumeros = 0;</p><p><span style="white-space: pre;"> </span>int listaOrdenada[20];</p><p><span style="white-space: pre;"> </span>int totalOrdenada = 0;</p><p><i><span style="color: #6aa84f;"><span style="white-space: pre;"> </span>//lectura por teclado de un conjunto de números positivos, como máximo 20 números</span></i></p><p><span style="white-space: pre;"> </span>while(!fin && totalNumeros<20){</p><p><span style="white-space: pre;"> </span>printf("ingrese un numero:");</p><p><span style="white-space: pre;"> </span>scanf("%d", &numero);</p><p><span style="white-space: pre;"> </span>if(numero > 0) {</p><p><span style="white-space: pre;"> </span>listaNumeros[totalNumeros]<span style="white-space: pre;"> </span>= numero;</p><p><span style="white-space: pre;"> </span>totalNumeros++;</p><p><span style="white-space: pre;"> </span>}else{</p><p><span style="white-space: pre;"> </span>fin++;</p><p><span style="white-space: pre;"> </span>}</p><p><span style="white-space: pre;"> </span>}</p><p><span style="white-space: pre;"> </span></p><p><span style="white-space: pre;"> </span><i><span style="color: #6aa84f;">//imprimir la lista</span></i></p><p><span style="white-space: pre;"> </span>for(int i = 0; i<totalNumeros; i++) printf("%d ", listaNumeros[i]);</p><p><span style="white-space: pre;"> </span></p><p><span style="white-space: pre;"> </span><span style="color: #6aa84f;"><i>//seleccionar los múltiplos de 5 ordenados descendente</i></span></p><p><span style="white-space: pre;"> </span>for(int i = 0; i<totalNumeros; i++){</p><p><span style="white-space: pre;"> </span>if( (listaNumeros[i]%5) == 0 ){</p><p><span style="white-space: pre;"> </span>int encuentra = 0;</p><p><span style="white-space: pre;"> </span>int indice;<span style="color: #6aa84f; font-size: x-small;"><i> //indice que recorre la lista ordenada para encontrar la posición donde insertar</i></span></p><p><span style="white-space: pre;"> </span>int multiploInsertar = listaNumeros[i];<span style="color: #6aa84f;"><i>//número a insertar en la lista ordenada</i></span></p><p><span style="white-space: pre;"> </span>indice = totalOrdenada - 1;</p><p><span style="white-space: pre;"> </span></p><p><span style="white-space: pre;"> </span><span style="color: #6aa84f;"><i>//recorremos la lista ordenada de forma descendente y vamos desplazando hasta qu encontramos la posición correcta</i></span></p><p><span style="white-space: pre;"> </span>while(!encuentra && indice >= 0){</p><p><span style="white-space: pre;"> </span><span style="color: #6aa84f; font-size: x-small;">//comparo el número a ubicar con el elemento en la ListaOrdenada en la posición índice</span></p><p><span style="white-space: pre;"> </span>if(multiploInsertar > listaOrdenada[indice]){</p><p><span style="white-space: pre;"> </span><i><span style="color: #6aa84f;">//como es mayor muevo el valor de lista ordenada al siguiente índice</span></i></p><p><span style="white-space: pre;"> </span>listaOrdenada[indice + 1 ] = listaOrdenada[indice];</p><p><span style="white-space: pre;"> </span>}</p><p><span style="white-space: pre;"> </span>else{</p><p><span style="white-space: pre;"> </span>listaOrdenada[indice+1] = multiploInsertar;</p><p><span style="white-space: pre;"> </span>totalOrdenada++;</p><p><span style="white-space: pre;"> </span>encuentra = 1;</p><p><span style="white-space: pre;"> </span>}</p><p><span style="white-space: pre;"> </span>indice--;</p><p><span style="white-space: pre;"> </span>}</p><p><span style="white-space: pre;"> </span>if(!encuentra) <span style="white-space: pre;"> </span>{<span style="color: #6aa84f;"><i>//en el caso que recorra todo el arrayOrdenado y sea mayor a todos, se coloca en el primer elemento</i></span></p><p><span style="white-space: pre;"> </span>listaOrdenada[0] = multiploInsertar;</p><p><span style="white-space: pre;"> </span>totalOrdenada++;</p><p><span style="white-space: pre;"> </span>}</p><p><span style="white-space: pre;"> </span></p><p><br /></p><p><span style="white-space: pre;"> </span>}</p><p><span style="white-space: pre;"> </span>}</p><p><span style="white-space: pre;"> </span></p><p><span style="white-space: pre;"> </span><i><span style="color: #6aa84f;">//imprimir la lista</span></i></p><p><span style="white-space: pre;"> </span>printf("\nNumero de multiplos encontrados %d\n", totalOrdenada);</p><p><span style="white-space: pre;"> </span>for(int i = 0; i<totalOrdenada; i++) printf("%d ", listaOrdenada[i]);</p><p><span style="white-space: pre;"> </span></p><p>return 0;</p><p>}</p>MIPBhttp://www.blogger.com/profile/15144077089562468638noreply@blogger.com0tag:blogger.com,1999:blog-8606551171960007078.post-79560345249330449002020-12-14T06:19:00.001-08:002020-12-15T07:37:06.231-08:00Problema de los rombos<p>El siguiente problema lo he venido encontrado a menudo en diferentes clases, el objetivo es el correcto manejo de la sentencia FOR y el printf.</p><p>Lo que busca es ingresar el valor de un número que representa el lado de un rombo e imprimir en pantalla el rombo. un ejemplo de ejecución:</p><p></p><div class="separator" style="clear: both; text-align: center;"><a href="https://blogger.googleusercontent.com/img/b/R29vZ2xl/AVvXsEiSA1R5NNubD0Y9d7Sj4rpXH4xV-3tn4NhG1oWTNLIF3PX47Gq3sSX-t3Mq5G8tXS9OcV3bWQ50Av1AKc7IzoVwebSkuBnw-A5aKTyHm3BpYL46lvxf-8Uym_x35-GMm6Ma0HjT8nSPHKU/" style="margin-left: 1em; margin-right: 1em;"><img alt="" data-original-height="301" data-original-width="436" height="221" src="https://blogger.googleusercontent.com/img/b/R29vZ2xl/AVvXsEiSA1R5NNubD0Y9d7Sj4rpXH4xV-3tn4NhG1oWTNLIF3PX47Gq3sSX-t3Mq5G8tXS9OcV3bWQ50Av1AKc7IzoVwebSkuBnw-A5aKTyHm3BpYL46lvxf-8Uym_x35-GMm6Ma0HjT8nSPHKU/" width="320" /></a></div><p><br /></p>Lo he resuelto utilizando un función para imprimir cada línea, de esta forma el programa me parece más ordenado.<p></p><p>Os dejo el código:</p><p>#include <iostream></p><p>void imprimirFila(int fila, int lado)</p><p>{</p><p><span style="white-space: pre;"> </span>//calculo de fila en el caso de estar en el triangulo inferior</p><p><span style="white-space: pre;"> </span>if(fila>lado) fila = (lado * 2) - fila;</p><p><span style="white-space: pre;"> </span>//calcular el número de blancos a imprimir</p><p><span style="white-space: pre;"> </span><span style="white-space: pre;">int </span>blancos = (lado * 2) - fila;</p><p><span style="white-space: pre;"> </span>//calcular el número de caracteres a imprimir</p><p><span style="white-space: pre;"> </span>int impreso = (fila * 2) - 1;</p><p><span style="white-space: pre;"> </span>//impresion de blancos</p><p><span style="white-space: pre;"> </span>for(int i=1; i<=blancos; i++) printf(" ");</p><p><span style="white-space: pre;"> </span>//impresion de caracteres</p><p><span style="white-space: pre;"> </span>for(int i=1; i<=impreso; i++) printf("X");</p><p><span style="white-space: pre;"> </span>//imprime salto de linea</p><p><span style="white-space: pre;"> </span>printf("\n");</p><p>}</p><p><br /></p><p>int main(int argc, char** argv) {</p><p><span style="white-space: pre;"> </span>//ingresa el valor del rombo</p><p><span style="white-space: pre;"> </span>int lado = 0;</p><p><span style="white-space: pre;"> </span>printf("ingrese el lado del rombo:");</p><p><span style="white-space: pre;"> </span>scanf("%d", &lado);</p><p><span style="white-space: pre;"> </span>printf("el valor del lado ingresado es: %d\n", lado);</p><p><span style="white-space: pre;"> </span></p><p><span style="white-space: pre;"> </span>//calculamos el número de lineas a imprimir</p><p><span style="white-space: pre;"> </span>int lineas = (lado * 2) - 1;</p><p><span style="white-space: pre;"> </span></p><p><span style="white-space: pre;"> </span>//un for para imprimir cada linea</p><p><span style="white-space: pre;"> </span>for(int fila = 1; fila<=lineas; fila++)</p><p><span style="white-space: pre;"> </span>{</p><p><span style="white-space: pre;"> </span>imprimirFila(fila, lado);</p><p><span style="white-space: pre;"> </span>}</p><p><span style="white-space: pre;"> </span>return 0;</p><p>}</p><p><br /><br /></p>MIPBhttp://www.blogger.com/profile/15144077089562468638noreply@blogger.com0tag:blogger.com,1999:blog-8606551171960007078.post-22467087825109471842016-09-17T10:25:00.000-07:002016-09-17T10:25:03.526-07:00Mostrar un menú de sistemaDespués de unas largas "vacaciones" vuelvo recargada de energía para empezar un nuevo curso, estos últimos meses he podido empezar mi web de docente que aún está en construcción, la voy avanzando poco a poco y ya os daré el enlace cuando esté terminada.<br />
<br />
Mientras tanto quiero compartir que hoy empecé con la primera alumna en este curso 2016-2017 y vimos un problema que se repite mucho, sobretodo en la facultad de Gestión Aeronáutica de la UAB (que últimamente son con los que más trabajo), se trata de mostrar un menú de sistema con distintas opciones:<br />
<br />
1. Empezar reserva<br />
2. Modificar reserva<br />
3. Facturar reserva<br />
4. Cancelar reserva<br />
5. Salir<br />
<br />
El menú se debe mostrar, realizar las acciones que el usuario seleccione y al terminar de ejecutar cada acción volver a mostrar el menú hasta que el usuario marque salir.<br />
<br />
El objetivo de este ejercicio es:<br />
<br />
- Reconocer que es necesario el uso de un bloque de instrucciones iterativas (while/for/do-while) para mostrar el menú hasta que el usuario decida salir<br />
- Reconocer que es más práctico utilizar el bloque de instrucciones switch en lugar de if's anidados<br />
<br />
A continuación muestro el código comentado en C++<br />
<br />
<span style="font-family: Courier New, Courier, monospace;">int main(int argc, char** argv) {</span><br />
<span style="font-family: Courier New, Courier, monospace;"><span class="Apple-tab-span" style="white-space: pre;"> </span><b><span style="color: #38761d;">//define una variable que guarde la opción seleccionada por el usuario</span></b></span><br />
<span style="font-family: Courier New, Courier, monospace;"><span class="Apple-tab-span" style="white-space: pre;"> </span>int opcion =0;</span><br />
<span style="font-family: Courier New, Courier, monospace;"><span class="Apple-tab-span" style="white-space: pre;"> </span><b><span style="color: #38761d;">//escogemos do-while para asegurar que el menú se muestre al menos la primera vez</span></b></span><br />
<span style="font-family: Courier New, Courier, monospace;"><span class="Apple-tab-span" style="white-space: pre;"> </span>do </span><br />
<span style="font-family: Courier New, Courier, monospace;"><span class="Apple-tab-span" style="white-space: pre;"> </span>{</span><br />
<span style="font-family: Courier New, Courier, monospace;"> <span style="color: #38761d;"><b>//imprimimos las opciones disponibles del menú</b></span></span><br />
<span style="font-family: Courier New, Courier, monospace;"><span class="Apple-tab-span" style="white-space: pre;"> </span>printf (" 1. Hacer reserva\n 2.Modificar reserva\n 3.Facturar reserva\n 4.Cancelar reserva\n 5.Salir\n");</span><br />
<span style="font-family: Courier New, Courier, monospace;"><br /></span>
<span style="font-family: Courier New, Courier, monospace;"> <b><span style="color: #38761d;">//leer de teclado la opción seleccionada por el usuario</span></b></span><br />
<span style="font-family: Courier New, Courier, monospace;"><span class="Apple-tab-span" style="white-space: pre;"> </span>printf ("Seleccione una opcion\n");</span><br />
<span style="font-family: Courier New, Courier, monospace;"><span class="Apple-tab-span" style="white-space: pre;"> </span>scanf ("%d",&opcion);</span><br />
<span class="Apple-tab-span" style="white-space: pre;"><span style="font-family: Courier New, Courier, monospace;"> </span></span><br />
<span style="font-family: Courier New, Courier, monospace;"> <b><span style="color: #38761d;">//utiliza el bloque switch para decidir que acción realiza según la opción seleccionada</span></b></span><br />
<span style="font-family: Courier New, Courier, monospace;"><span class="Apple-tab-span" style="white-space: pre;"> </span>switch (opcion) </span><br />
<span style="font-family: Courier New, Courier, monospace;"><span class="Apple-tab-span" style="white-space: pre;"> </span>{</span><br />
<span style="font-family: Courier New, Courier, monospace;"><span class="Apple-tab-span" style="white-space: pre;"> </span>case 1: printf ("Haciendo reserva\n");</span><br />
<span style="font-family: Courier New, Courier, monospace;"><span class="Apple-tab-span" style="white-space: pre;"> </span>break;</span><br />
<span style="font-family: Courier New, Courier, monospace;"><span class="Apple-tab-span" style="white-space: pre;"> </span>case 2: printf ("Modificando reserva\n");</span><br />
<span style="font-family: Courier New, Courier, monospace;"><span class="Apple-tab-span" style="white-space: pre;"> </span>break;</span><br />
<span style="font-family: Courier New, Courier, monospace;"><span class="Apple-tab-span" style="white-space: pre;"> </span>case 3: printf ("Facturando reserva\n");</span><br />
<span style="font-family: Courier New, Courier, monospace;"><span class="Apple-tab-span" style="white-space: pre;"> </span>break;</span><br />
<span style="font-family: Courier New, Courier, monospace;"><span class="Apple-tab-span" style="white-space: pre;"> </span>case 4: printf ("Cancelar reserva\n");</span><br />
<span style="font-family: Courier New, Courier, monospace;"><span class="Apple-tab-span" style="white-space: pre;"> </span>break;</span><br />
<span style="font-family: Courier New, Courier, monospace;"><span class="Apple-tab-span" style="white-space: pre;"> </span>case 5: printf ("Salir\n");</span><br />
<span style="font-family: Courier New, Courier, monospace;"><span class="Apple-tab-span" style="white-space: pre;"> </span>break;</span><br />
<span class="Apple-tab-span" style="white-space: pre;"><span style="font-family: Courier New, Courier, monospace;"> </span></span><br />
<span style="font-family: Courier New, Courier, monospace;"><span class="Apple-tab-span" style="white-space: pre;"> </span>default: printf ("Opcion incorrecta\n");</span><br />
<span style="font-family: Courier New, Courier, monospace;"><span class="Apple-tab-span" style="white-space: pre;"> </span>break;</span><br />
<span style="font-family: Courier New, Courier, monospace;"><span class="Apple-tab-span" style="white-space: pre;"> </span>}</span><br />
<span style="font-family: Courier New, Courier, monospace;"><span class="Apple-tab-span" style="white-space: pre;"> </span>}</span><br />
<span style="font-family: Courier New, Courier, monospace;"><span class="Apple-tab-span" style="white-space: pre;"> </span>while (opcion !=5);<b><span style="color: #38761d;">//en caso que seleccione la opción 5 termina de ejecutar la iteración</span></b></span><br />
<span class="Apple-tab-span" style="white-space: pre;"><span style="font-family: Courier New, Courier, monospace;"> </span></span><br />
<span style="font-family: Courier New, Courier, monospace;"><span class="Apple-tab-span" style="white-space: pre;"> </span>return 0;</span><br />
<span style="font-family: Courier New, Courier, monospace;">}</span><br />
<br />
A continuación muestro unas capturas de pantalla de la ejecución:<br />
<br />
<div class="separator" style="clear: both; text-align: center;">
<a href="https://blogger.googleusercontent.com/img/b/R29vZ2xl/AVvXsEhW2SYhyphenhyphenL8u3bTr388YLVSBb2Vn2cQgB34fUFcOO_qsFM5wkAcn1UH-26dDf2KWIhzl4ggsVqPhEp-TJSNaHdtsX4moEq2IO45BiffoTt8mNm32ZBlFi6bb63QLRhJ7HGU8grVMYXnS9D4/s1600/Menu1.PNG" imageanchor="1" style="margin-left: 1em; margin-right: 1em;"><img border="0" height="272" src="https://blogger.googleusercontent.com/img/b/R29vZ2xl/AVvXsEhW2SYhyphenhyphenL8u3bTr388YLVSBb2Vn2cQgB34fUFcOO_qsFM5wkAcn1UH-26dDf2KWIhzl4ggsVqPhEp-TJSNaHdtsX4moEq2IO45BiffoTt8mNm32ZBlFi6bb63QLRhJ7HGU8grVMYXnS9D4/s400/Menu1.PNG" width="400" /></a></div>
<div class="separator" style="clear: both; text-align: center;">
<br /></div>
<div class="separator" style="clear: both; text-align: center;">
<a href="https://blogger.googleusercontent.com/img/b/R29vZ2xl/AVvXsEisVcdppD0sjBFLZWCGpDg-Mru8kymkiDH-7HGYLid4fsDndKJj5EXJmBHdbcmxmXaPpCxyN6rIDd1Vss7oN0NqjEXs5TN_RVskBQEGvOLO8ZZG77khM_amPNn-GSKXt32rd3tWc6Pkoe0/s1600/Menu2.png" imageanchor="1" style="margin-left: 1em; margin-right: 1em;"><img border="0" height="176" src="https://blogger.googleusercontent.com/img/b/R29vZ2xl/AVvXsEisVcdppD0sjBFLZWCGpDg-Mru8kymkiDH-7HGYLid4fsDndKJj5EXJmBHdbcmxmXaPpCxyN6rIDd1Vss7oN0NqjEXs5TN_RVskBQEGvOLO8ZZG77khM_amPNn-GSKXt32rd3tWc6Pkoe0/s400/Menu2.png" width="400" /></a></div>
<br />
<br />
<div class="separator" style="clear: both; text-align: center;">
<a href="https://blogger.googleusercontent.com/img/b/R29vZ2xl/AVvXsEga75jy263zs7VPOuPk4vez3PRzscOPb_T8n4dmWUcEMoKRek6ON1NX-gSUELT_jFmh7q8ezgv1M_StEM_M9AoCDGnkBW1ao0yhXkOQr5-D4rOFxQTCkGwQYYuvW1aQspZ9iiKdRp7Nk-A/s1600/Menu3.png" imageanchor="1" style="margin-left: 1em; margin-right: 1em;"><img border="0" height="293" src="https://blogger.googleusercontent.com/img/b/R29vZ2xl/AVvXsEga75jy263zs7VPOuPk4vez3PRzscOPb_T8n4dmWUcEMoKRek6ON1NX-gSUELT_jFmh7q8ezgv1M_StEM_M9AoCDGnkBW1ao0yhXkOQr5-D4rOFxQTCkGwQYYuvW1aQspZ9iiKdRp7Nk-A/s400/Menu3.png" width="400" /></a></div>
<br />
<br />
<br />
<br />
<br />MIPBhttp://www.blogger.com/profile/15144077089562468638noreply@blogger.com0tag:blogger.com,1999:blog-8606551171960007078.post-54542417578951610542016-07-03T07:46:00.001-07:002016-07-03T07:46:33.441-07:00Cursores Programación SQLPara variar un poco, veremos algo de SQL, en este caso serán los cursores.<br />
<br />
<b>¿Qué es un cursor?</b><br />
De forma sencilla podemos decir que es una especie de tipo de variable que se genera a partir de una select y cuyos datos son <b>dinámicos</b>, dependerán de los parámetros que se le pase.<br />
Los cursores son similares a las <a href="http://ejemplosalgoritmos.blogspot.com.es/2013/10/estructuras-struct.html">estructuras</a>, son tipos de datos que podemos crearlos, pero si no los usamos no servirán de nada.<br />
<br />
Un ejemplo de declaración de un cursor es:<br />
<span style="font-family: Courier New, Courier, monospace;">DECLARE MiCursor CURSOR </span><br />
<span style="font-family: Courier New, Courier, monospace;"> FOR SELECT campo2 FROM miTabla WHERE campo1 = @valorCampo1 </span><br />
<span style="font-family: Courier New, Courier, monospace;"><br /></span>
<b>MiCursor: </b>Es el nombre del nuevo tipo de datos<br />
<b>miTabla: </b>es el nombre de la tabla que estamos consultando<br />
<b>campo1 y campo 2: </b>son campos de la tabla miTabla<br />
<b>@valorCampo1: </b>es el parámetro que se le pasa al cursos para poder obtener la información de forma dinámica<br />
<br />
Si ningún programa utiliza el cursor MiCursor que hemos creado entonces será un tipo de datos inservible.<br />
Para utilizarlo debemos recordar la <a href="http://ejemplosalgoritmos.blogspot.com.es/2016/03/lectura-de-fichero-de-texto.html">lectura de ficheros</a>, era como la lectura de un vinilo, el cursor es de la misma forma, el resultado de la select es un conjunto de registros en donde cada registro será similar a una linea leída en el fichero. De la misma forma forma como hacemos con un fichero, un cursor debe abrirse y cerrarse, para leer el registro primero nos posicionamos en él mediante la instrucción FETCH, luego de posicionarnos podemos leerlo.<br />
El algoritmo sería el siguiente:<br />
1. Inicializamos los parametros que necesite el cursor<br />
2. Abrimos el cursor<br />
3. Nos posicionamos en el primer registro<br />
4. Leemos registro a registro hasta que lleguemos al último, en este caso el FETCH devolverá un estado de finalización.<br />
5. Cerramos el cursor<br />
<br />
Aplicamos el algoritmo al ejemplo:<br />
@valorCampo1 = 1 <span style="color: #38761d;">--inicializamos el parámetro </span><br />
OPEN MiCursor <span style="color: #38761d;">--abrimos el cursor</span><br />
FETCH NEXT FROM MiCursor INTO @registro <span style="color: #38761d;">--se posiciona en el primer registro, la variable @registro debe tener el mismo formato que campo2</span> <br />
WHILE @@FETCH_STATUS = 0 <span style="color: #38761d;">--lee hasta encontrar el estado de finalización</span><br />
BEGIN <br />
FETCH NEXT FROM MiCursor INTO @registro <span style="color: #38761d;">--lectura de siguiente registro</span><br />
END <br />
CLOSE MiCursor <span style="color: #38761d;">--cierre de cursor</span><br />
<span style="color: #38761d;"><br /></span>
Para tener claro el funcionamiento de cursores es necesario tener claro el concepto de estructuras, de lectura de ficheros, y por supuesto de sentencias SQL y procedimientos.<br />
<span style="color: #38761d;"><br /></span>Anonymousnoreply@blogger.com0tag:blogger.com,1999:blog-8606551171960007078.post-39101766769391439102016-05-24T14:39:00.004-07:002016-05-24T14:54:44.886-07:00Ordenamiento de una lista simplemente enlazada<div style="margin-bottom: 0cm;">
<span style="font-size: 11pt;">El
ordenamiento de una lista simplemente enlazada es similar al
<b><a href="http://ejemplosalgoritmos.blogspot.com.es/2013/08/vectores-ordenamiento-por-intercambio.html">ordenamiento de vectores</a> </b>con
la gran diferencia de que en una lista simplemente enlazada no
disponemos del concepto del “índice” que nos ayuda a acceder
directamente a un elemento de la lista, en este caso para acceder a
un elemento debemos recorrer desde el inicio hasta hallar el elemento
que nos interese.</span></div>
<div style="margin-bottom: 0cm;">
<br /></div>
<div style="margin-bottom: 0cm;">
<span style="font-size: 11pt;">Un
algoritmo sencillo es el del Intercambio, consiste en lo siguiente:</span></div>
<div style="margin-bottom: 0cm;">
<br /></div>
<div style="margin-bottom: 0cm;">
<span style="font-size: 11pt;">1.
Situar un puntero al inicio de la lista que nos irá indicando a
medida que vayamos ordenando, cuánto de la lista ya está ordenada,
es la variable más importante del algoritmo porque nos servirá para
saber que hemos acabado de ordenar la lista.</span></div>
<div style="margin-bottom: 0cm;">
<br /></div>
<div style="margin-bottom: 0cm;">
<span style="font-family: "courier new" , monospace;"><span style="font-size: x-small;">Elemento
* elemBase = elemInicio;</span></span></div>
<div style="margin-bottom: 0cm;">
<span style="font-family: "courier new" , monospace;"><span style="font-size: x-small;">while(elemBase
!= NULL)</span></span></div>
<div style="margin-bottom: 0cm;">
<span style="font-family: "courier new" , monospace;"><span style="font-size: x-small;">{</span></span></div>
<div style="margin-bottom: 0cm;">
<span style="font-family: "courier new" , monospace;"><span style="color: #38761d; font-size: x-small;">//en
este proceso vamos ordenando la lista a partir del nodo elemBase
hasta el final</span></span></div>
<div style="margin-bottom: 0cm;">
<span style="font-family: "courier new" , monospace;"><span style="font-size: x-small;">elemBase
= elemBase->next;</span></span></div>
<div style="margin-bottom: 0cm;">
<span style="font-family: "courier new" , monospace;"><span style="font-size: x-small;">}</span></span></div>
<div style="margin-bottom: 0cm;">
<br /></div>
<div style="margin-bottom: 0cm;">
<span style="font-size: 11pt;">2.
En el caso que el ordenamiento sea de menor a mayor, necesitamos
encontrar el menor de los elementos a partir del elemento base hasta
el final de la lista.</span></div>
<div style="margin-bottom: 0cm;">
<span style="font-size: 11pt;">En
el caso del ordenamiento de Vectores obteníamos la posición, en
este caso obtendremos un puntero al menor elemento.</span></div>
<div style="margin-bottom: 0cm;">
<span style="font-size: x-small;"><br /></span></div>
<div style="margin-bottom: 0cm;">
<span style="font-family: "courier new" , monospace;"><span style="font-size: x-small;">Elemento*
buscarMenor(Elemento* ptrInicial)</span></span></div>
<div style="margin-bottom: 0cm;">
<br /></div>
<div style="margin-bottom: 0cm;">
<span style="font-size: 11pt;">Esta
función tendría que utilizarse en cada iteración</span></div>
<div style="margin-bottom: 0cm;">
<br /></div>
<div style="margin-bottom: 0cm;">
<span style="font-family: "courier new" , monospace;"><span style="font-size: x-small;">Elemento
* elemBase = elemInicio;</span></span></div>
<div style="margin-bottom: 0cm;">
<span style="font-family: "courier new" , monospace;"><span style="font-size: x-small;">Elemento*
elemMenor; <span style="color: #38761d;">//puntero que nos sirve para apuntar al menor elemento
</span>encontrado</span></span></div>
<div style="margin-bottom: 0cm;">
<span style="font-family: "courier new" , monospace;"><span style="font-size: x-small;">while(elemBase
!= NULL)</span></span></div>
<div style="margin-bottom: 0cm;">
<span style="font-family: "courier new" , monospace;"><span style="font-size: x-small;">{</span></span></div>
<div style="margin-bottom: 0cm;">
<span style="font-family: "courier new" , monospace;"><span style="font-size: x-small;">elemMenor
= buscarMenor(elemBase);</span></span></div>
<div style="margin-bottom: 0cm;">
<span style="font-family: "courier new" , monospace;"><span style="font-size: x-small;">elemBase
= elemBase->next;</span></span></div>
<div style="margin-bottom: 0cm;">
<span style="font-family: "courier new" , monospace;"><span style="font-size: x-small;">}</span></span></div>
<div style="margin-bottom: 0cm;">
<br /></div>
<div style="margin-bottom: 0cm;">
<span style="font-size: 11pt;">3.
Intercambiar el elemento menor con el elemento que se encuentra
apuntando el puntero base. Para hacer este intercambio es necesario
que el elemento anterior al elemento base apunte al elemento menor,
para eso necesitamos un puntero que apunte al anterior del elemento
base.</span></div>
<div style="margin-bottom: 0cm;">
<br /></div>
<div style="margin-bottom: 0cm;">
<span style="font-size: 11pt;">Como
es una lista simplemente enlazada, no podemos retroceder para hallar
al puntero anterior al puntero base, por tanto, crearemos una función
que nos sirva para ubicarnos en el elemento anterior que queramos.
Esta función es necesaria para luego poder hacer el intercambio de
nodos.</span></div>
<div style="margin-bottom: 0cm;">
<br /></div>
<div style="margin-bottom: 0cm;">
<span style="font-family: "courier new" , monospace;"><span style="font-size: x-small;">Elemento
* getElemAnterior(Elemento* elemInicio, Elemento* elem);</span></span></div>
<div style="margin-bottom: 0cm;">
<br /></div>
<div style="margin-bottom: 0cm;">
<span style="font-size: 11pt;">Utilizaremos
esta función para obtener el elemento anterior al base y al menor y
de esta forma poder realizar el intercambio</span></div>
<div style="margin-bottom: 0cm;">
<br /></div>
<div style="margin-bottom: 0cm;">
<span style="font-family: "courier new" , monospace;"><span style="font-size: x-small;">Elemento
* elemAnteBase = NULL;<span style="color: #38761d;">//puntero que apunta al anterior de elemento
base</span></span></span></div>
<div style="margin-bottom: 0cm;">
<span style="font-family: "courier new" , monospace;"><span style="font-size: x-small;">Elemento
* elemBase = elemInicio;</span></span></div>
<div style="margin-bottom: 0cm;">
<span style="font-family: "courier new" , monospace;"><span style="font-size: x-small;">Elemento*
elemAnteMenor; <span style="color: #38761d;">//puntero que apunta al anterior del elemento menor</span></span></span></div>
<div style="margin-bottom: 0cm;">
<span style="font-family: "courier new" , monospace;"><span style="font-size: x-small;">Elemento*
elemMenor; <span style="color: #38761d;">//puntero que nos sirve para apuntar al menor elemento</span>
encontrado</span></span></div>
<div style="margin-bottom: 0cm;">
<span style="font-family: "courier new" , monospace;"><span style="font-size: x-small;">while(elemBase
!= NULL)</span></span></div>
<div style="margin-bottom: 0cm;">
<span style="font-family: "courier new" , monospace;"><span style="font-size: x-small;">{</span></span></div>
<div style="margin-bottom: 0cm;">
<span style="font-family: "courier new" , monospace;"><span style="font-size: x-small;">elemMenor
= buscarMenor(elemBase);</span></span></div>
<div style="margin-bottom: 0cm;">
<span style="font-family: "courier new" , monospace;"><span style="font-size: x-small;">elemAnteBase
= getElemAnterior(elemInicio, elemBase);</span></span></div>
<div style="margin-bottom: 0cm;">
<span style="font-family: "courier new" , monospace;"><span style="font-size: x-small;">elemAnteMenor
= getElemAnterior(elemInicio, elemMenor);</span></span></div>
<div style="margin-bottom: 0cm;">
<span style="font-family: "courier new" , monospace;"><span style="font-size: x-small;">elemBase
= elemBase->next;</span></span></div>
<div style="margin-bottom: 0cm;">
<span style="font-family: "courier new" , monospace;"><span style="font-size: x-small;">}</span></span></div>
<div style="margin-bottom: 0cm;">
<br /></div>
<div style="margin-bottom: 0cm;">
<span style="font-size: 11pt;">Teniendo
el puntero anterior al base ya podemos hacer el intercambio:</span></div>
<div style="margin-bottom: 0cm;">
<br /></div>
<div style="margin-bottom: 0cm;">
<span style="font-size: x-small;"><span style="font-family: "courier new" , monospace;"><span style="font-size: xx-small;">void
intercambio(Elemento* elemAnteBase, Elemento* elemBase, </span></span>
</span></div>
<div style="margin-bottom: 0cm;">
<span style="font-family: "courier new" , monospace;"><span style="font-size: x-small;">Elemento*
elemAnteMenor, Elemento* elemMenor);</span></span></div>
<div style="margin-bottom: 0cm;">
<br /></div>
<div style="margin-bottom: 0cm;">
<span style="font-size: 11pt;">Incorporamos
el intercambio en cada iteración y asignamos el nodo menor como el
nuevo elemento base:</span></div>
<div style="margin-bottom: 0cm;">
<br /></div>
<div style="margin-bottom: 0cm;">
<span style="font-family: "courier new" , monospace;"><span style="font-size: x-small;">Elemento
* elemAnteBase = NULL;<span style="color: #38761d;">//puntero que apunta al anterior de elemento
base</span></span></span></div>
<div style="margin-bottom: 0cm;">
<span style="font-family: "courier new" , monospace;"><span style="font-size: x-small;">Elemento
* elemBase = elemInicio;</span></span></div>
<div style="margin-bottom: 0cm;">
<span style="font-family: "courier new" , monospace;"><span style="font-size: x-small;">Elemento*
elemAnteMenor; <span style="color: #38761d;">//puntero que apunta al anterior del elemento menor</span></span></span></div>
<div style="margin-bottom: 0cm;">
<span style="font-family: "courier new" , monospace;"><span style="font-size: x-small;">Elemento*
elemMenor; <span style="color: #38761d;">//puntero que nos sirve para apuntar al menor elemento
</span>encontrado</span></span></div>
<div style="margin-bottom: 0cm;">
<span style="font-family: "courier new" , monospace;"><span style="font-size: x-small;">while(elemBase
!= NULL)</span></span></div>
<div style="margin-bottom: 0cm;">
<span style="font-family: "courier new" , monospace;"><span style="font-size: x-small;">{</span></span></div>
<div style="margin-bottom: 0cm;">
<span style="font-family: "courier new" , monospace;"><span style="font-size: x-small;">elemMenor
= buscarMenor(elemBase);</span></span></div>
<div style="margin-bottom: 0cm;">
<span style="font-family: "courier new" , monospace;"><span style="font-size: x-small;">elemAnteBase
= getElemAnterior(elemInicio, elemBase);</span></span></div>
<div style="margin-bottom: 0cm;">
<span style="font-family: "courier new" , monospace;"><span style="font-size: x-small;">elemAnteMenor
= getElemAnterior(elemInicio, elemMenor);</span></span></div>
<div style="margin-bottom: 0cm;">
<span style="font-family: "courier new" , monospace;"><span style="font-size: x-small;">intercambio(elemAnteBase,
elemBase, elemAnteMenor, elemMenor);</span></span></div>
<div style="margin-bottom: 0cm;">
<span style="font-family: "courier new" , monospace;"><span style="font-size: x-small;">elemBase
= elemMenor;</span></span></div>
<div style="margin-bottom: 0cm;">
<span style="font-family: "courier new" , monospace;"><span style="font-size: x-small;">elemBase
= elemBase->next;</span></span></div>
<div style="margin-bottom: 0cm;">
<span style="font-family: "courier new" , monospace;"><span style="font-size: x-small;">}</span></span></div>
<div style="margin-bottom: 0cm;">
<br /></div>
<div style="margin-bottom: 0cm;">
<span style="font-size: 11pt;">4.
Finalmente desarrollamos las funciones:</span></div>
<div style="margin-bottom: 0cm;">
<br /></div>
<div style="margin-bottom: 0cm;">
<span style="font-family: "courier new" , monospace;"><span style="font-size: x-small;">Elemento*
buscarMenor(Elemento* ptrInicial)</span></span></div>
<div style="margin-bottom: 0cm;">
<span style="font-family: "courier new" , monospace;"><span style="font-size: x-small;">{</span></span></div>
<div style="margin-bottom: 0cm;">
<span style="font-family: "courier new" , monospace;"><span style="font-size: x-small;">Elemento*
elemMenor = ptrInicial;</span></span></div>
<div style="margin-bottom: 0cm;">
<span style="font-family: "courier new" , monospace;"><span style="font-size: x-small;">Elemento*
ptr = ptrInicial;<span style="color: #38761d;">//puntero que sirve para recorrer la lista</span></span></span></div>
<div style="margin-bottom: 0cm;">
<span style="font-family: "courier new" , monospace;"><span style="font-size: x-small;">int
menorValor = elemMenor.valor;<span style="color: #38761d;">//inicializamos el primer valor menor</span></span></span></div>
<div style="margin-bottom: 0cm;">
<span style="font-family: "courier new" , monospace;"><span style="color: #38761d; font-size: x-small;">//recorremos
toda la lista y dejamos el puntero elemMenor en el de menor valor</span></span></div>
<div style="margin-bottom: 0cm;">
<span style="font-family: "courier new" , monospace;"><span style="font-size: x-small;">while(ptr!=NULL)</span></span></div>
<div style="margin-bottom: 0cm;">
<span style="font-family: "courier new" , monospace;"><span style="font-size: x-small;">{</span></span></div>
<div style="margin-bottom: 0cm;">
<span style="font-family: "courier new" , monospace;"><span style="font-size: x-small;">if(ptr.valor <
menorValor)</span></span></div>
<div style="margin-bottom: 0cm;">
<span style="font-family: "courier new" , monospace;"><span style="font-size: x-small;">{</span></span></div>
<div style="margin-bottom: 0cm;">
<span style="font-family: "courier new" , monospace;"><span style="font-size: x-small;">elemMenor = ptr;</span></span></div>
<div style="margin-bottom: 0cm;">
<span style="font-family: "courier new" , monospace;"><span style="font-size: x-small;">menorValor =
ptr.valor;</span></span></div>
<div style="margin-bottom: 0cm;">
<span style="font-family: "courier new" , monospace;"><span style="font-size: x-small;">}</span></span></div>
<div style="margin-bottom: 0cm;">
<span style="font-family: "courier new" , monospace;"><span style="font-size: x-small;">ptr
= ptr->next;</span></span></div>
<div style="margin-bottom: 0cm;">
<span style="font-family: "courier new" , monospace;"><span style="font-size: x-small;">}</span></span></div>
<div style="margin-bottom: 0cm;">
<span style="font-family: "courier new" , monospace;"><span style="font-size: x-small;">return
elemMenor;</span></span></div>
<div style="margin-bottom: 0cm;">
<span style="font-family: "courier new" , monospace;"><span style="font-size: x-small;">}</span></span></div>
<div style="margin-bottom: 0cm;">
<span style="font-size: x-small;"><br /></span></div>
<div style="margin-bottom: 0cm;">
<span style="font-size: x-small;"><span style="font-family: "courier new" , monospace;"><span style="font-size: xx-small;">void
intercambio(Elemento* elemAnteBase, Elemento* elemBase, </span></span>
</span></div>
<div style="margin-bottom: 0cm;">
<span style="font-family: "courier new" , monospace;"><span style="font-size: x-small;">Elemento*
elemAnteMenor, Elemento* elemMenor)</span></span></div>
<div style="margin-bottom: 0cm;">
<span style="font-family: "courier new" , monospace;"><span style="font-size: x-small;">{</span></span></div>
<div style="margin-bottom: 0cm;">
<span style="font-family: "courier new" , monospace;"><span style="font-size: x-small;">Elemento*
aux = elemBase->next; <span style="color: #38761d;">//nos sirve para hacer el intercambio sin
perder punteros</span></span></span></div>
<div style="margin-bottom: 0cm;">
<span style="font-family: "courier new" , monospace;"><span style="font-size: x-small;">elemBase->next =
elemMenor->next;</span></span></div>
<div style="margin-bottom: 0cm;">
<span style="font-family: "courier new" , monospace;"><span style="font-size: x-small;">elemMenor->next =
aux;</span></span></div>
<div style="margin-bottom: 0cm;">
<span style="font-family: "courier new" , monospace;"><span style="font-size: x-small;">elemAnteBase->next
= elemMenor;</span></span></div>
<div style="margin-bottom: 0cm;">
<span style="font-family: "courier new" , monospace;"><span style="font-size: x-small;">elemAnteMenor->next
= elemBase;</span></span></div>
<div style="margin-bottom: 0cm;">
<span style="font-family: "courier new" , monospace;"><span style="font-size: x-small;">}</span></span></div>
<div style="margin-bottom: 0cm;">
<span style="font-size: x-small;"><br /></span></div>
<div style="margin-bottom: 0cm;">
<span style="font-family: "courier new" , monospace;"><span style="font-size: x-small;">Elemento
* getElemAnterior(Elemento* elemInicio, Elemento* elem)</span></span></div>
<div style="margin-bottom: 0cm;">
<span style="font-family: "courier new" , monospace;"><span style="font-size: x-small;">{</span></span></div>
<div style="margin-bottom: 0cm;">
<span style="font-family: "courier new" , monospace;"><span style="font-size: x-small;">Elemento*anterior =
NULL;</span></span></div>
<div style="margin-bottom: 0cm;">
<span style="font-family: "courier new" , monospace;"><span style="font-size: x-small;">Elemento*ptr
= elemInicio;</span></span></div>
<div style="margin-bottom: 0cm;">
<span style="font-family: "courier new" , monospace;"><span style="font-size: x-small;">int
finBusqueda = 0;</span></span></div>
<div style="margin-bottom: 0cm;">
<span style="font-family: "courier new" , monospace;"><span style="font-size: x-small;">while(ptr!=NULL &&
ptr->next!=NULL && !finBusqueda)</span></span></div>
<div style="margin-bottom: 0cm;">
<span style="font-family: "courier new" , monospace;"><span style="font-size: x-small;">{</span></span></div>
<div style="margin-bottom: 0cm;">
<span style="font-family: "courier new" , monospace;"><span style="font-size: x-small;">if(ptr->next.valor
== elem.valor)</span></span></div>
<div style="margin-bottom: 0cm;">
<span style="font-family: "courier new" , monospace;"><span style="font-size: x-small;">{</span></span></div>
<div style="margin-bottom: 0cm;">
<span style="font-family: "courier new" , monospace;"><span style="font-size: x-small;">finBusqueda = 1;</span></span></div>
<div style="margin-bottom: 0cm;">
<span style="font-family: "courier new" , monospace;"><span style="font-size: x-small;">}</span></span></div>
<div style="margin-bottom: 0cm;">
<span style="font-family: "courier new" , monospace;"><span style="font-size: x-small;">anterior
= ptr;</span></span></div>
<div style="margin-bottom: 0cm;">
<span style="font-family: "courier new" , monospace;"><span style="font-size: x-small;">ptr
= ptr->next;</span></span></div>
<div style="margin-bottom: 0cm;">
<span style="font-family: "courier new" , monospace;"><span style="font-size: x-small;">}</span></span></div>
<div style="margin-bottom: 0cm;">
<span style="font-family: "courier new" , monospace;"><span style="font-size: x-small;">return
anterior;</span></span></div>
<span style="font-size: x-small;"><br /></span>
<br />
<div style="margin-bottom: 0cm;">
<span style="font-family: "courier new" , monospace;"><span style="font-size: x-small;">}</span></span></div>
<div style="margin-bottom: 0cm;">
<span style="font-family: "courier new" , monospace;"><span style="font-size: x-small;"><br /></span></span></div>
<div style="margin-bottom: 0cm;">
<span style="font-family: "courier new" , monospace;"><span style="font-size: x-small;"><br /></span></span></div>
<div style="margin-bottom: 0cm;">
<span style="font-family: "courier new" , monospace;"><span style="font-size: x-small;"><br /></span></span></div>
<div style="margin-bottom: 0cm;">
<span style="font-family: "courier new" , monospace;"><span style="font-size: x-small;"><br /></span></span></div>
Anonymousnoreply@blogger.com0tag:blogger.com,1999:blog-8606551171960007078.post-27909313318326432682016-03-28T07:30:00.001-07:002016-03-28T07:30:17.995-07:00Lectura de fichero de textoEn este post veremos los pasos para realizar la lectura de un fichero de texto, para esto es necesario saber que es similar a escuchar música en un vinilo, se deben realizar pasos:<br />
<br />
1- Poner el disco y la aguja al inicio del disco.<br />
2- Escuchar la música.<br />
3- Levantar la aguja cuando ya no se quiera escuchar o esperar a que termine de reproducirlo todo.<br />
<br />
La aguja en el disco viene a representar un puntero de tipo FILE* que se prepara al inicio del fichero, avanza con cada caracter que lee y finalmente debemos cerrarlo.<br />
<br />
Fichero que leeremos:<br />
<div class="separator" style="clear: both; text-align: center;">
<a href="https://blogger.googleusercontent.com/img/b/R29vZ2xl/AVvXsEgoV2lXoPb43zIfdyajlVZ1J05Qj5quMkcp8ouWm6haTDJelnIQOJIrDF_QIfuwIL13elfy4ccHyfqv8i0YZZipfHnYTX6CxL2dTo1lBrJg_Ul-28yzuY8sWGy34c2VKaz4VQSPdSoqArk/s1600/fihcero_prueba.jpg" imageanchor="1" style="margin-left: 1em; margin-right: 1em;"><img border="0" height="168" src="https://blogger.googleusercontent.com/img/b/R29vZ2xl/AVvXsEgoV2lXoPb43zIfdyajlVZ1J05Qj5quMkcp8ouWm6haTDJelnIQOJIrDF_QIfuwIL13elfy4ccHyfqv8i0YZZipfHnYTX6CxL2dTo1lBrJg_Ul-28yzuY8sWGy34c2VKaz4VQSPdSoqArk/s320/fihcero_prueba.jpg" width="320" /></a></div>
<br />
<br />
<b>Primer Paso: Abrir Fichero</b><br />
FILE* abrirFichero () {<br />
FILE* fptr = NULL; <span style="color: #38761d;">//puntero que abre al inicio del fichero y sirve para recorrerlo</span><br />
fptr = fopen ("fichero_prueba.txt", "rt"); <span style="color: #38761d;">//apertura de fichero con permiso de lectura</span><br />
return fptr;<br />
}<br />
<br />
Invocación de la función abrirFichero:<br />
<span style="color: blue;"><b>FILE* ptrFichero;</b></span> <span style="color: #38761d;">//declaramos una variable de tipo puntero</span><br />
<b><span style="color: blue;">ptrFichero = abrirFichero (); </span></b><span style="color: #38761d;">//invocamos a la función y guardamos el resultado en la variable puntero</span><br />
<br />
<b>Segundo Paso: Leer Fichero</b><br />
Esta función leerá el fichero hasta el final<br />
<br />
void leerFichero(FILE* fptr )<br />
{<br />
char palabra1 [BUFSIZ];<br />
char palabra2 [BUFSIZ];<br />
int numero;<br />
<span style="color: #38761d;"> //La función eof = End Of File devuelve true cuando el puntero llega al final del fichero</span><br />
while(!feof(fptr))<br />
{<br />
<span style="color: #38761d;"> //leemos palabra a palabra (se sabe previamente el formato del fichero)</span><br />
<span style="color: #38761d;"> //sabemos que leemos 2 palabras y un número por registro</span><br />
<span style="color: #38761d;"> //cada iteración del while leerá un registro</span><br />
fscanf (fptr, "%s", palabra1);<br />
fscanf (fptr, "%s", palabra2);<br />
fscanf (fptr, "%i",&numero);<br />
<span style="color: #38761d;">//imprimimos por pantalla lo que hemos leído</span><br />
printf("palabra 1: %s, palabra 2: %s, numero: %i \n", palabra1, palabra2, numero);<br />
}<br />
}<br />
<br />
Invocación de la función leerFichero:<br />
Sólo puede realizarse si el fichero se llego a abrir (ptrFichero != NULL)<br />
FILE* ptrFichero;<br />
ptrFichero = abrirFichero ();<br />
<span style="color: blue;"><b>if(ptrFichero != NULL)</b></span><br />
<span style="color: blue;"><b>{</b></span><br />
<span style="color: blue;"><b> leerFichero(ptrFichero);</b></span><br />
<span style="color: blue;"><b>}</b></span><br />
<br />
<b>Tercer Paso: Cerrar Fichero</b><br />
void cerrarFichero (FILE* fptr) {<br />
fclose(fptr);<br />
}<br />
<br />
Invocación de la función leerFichero:<br />
Sólo puede realizarse si el fichero se llego a abrir (ptrFichero != NULL)<br />
FILE* ptrFichero;<br />
ptrFichero = abrirFichero ();<br />
if(ptrFichero != NULL)<br />
{<br />
leerFichero(ptrFichero);<br />
<b><span style="color: blue;">cerrarFichero(ptrFichero);</span></b><br />
}<br />
<br />
El resultado de la ejecución es el siguiente:<br />
<br />
<div class="separator" style="clear: both; text-align: center;">
<a href="https://blogger.googleusercontent.com/img/b/R29vZ2xl/AVvXsEg4a97QBZKUpAj8fDLzoFvnCKtjlVHNNCh8s9YPzjSKrKJXq4ewzDKWvdpIn3bE5PreL86mHAO3xDuPBg3zellWfvaLOMuA2KbzTFigEDnFp66aeo1O4ROkVvbMqNyj5gT_sVMV6kpTlfU/s1600/resultadoFichero.jpg" imageanchor="1" style="margin-left: 1em; margin-right: 1em;"><img border="0" height="252" src="https://blogger.googleusercontent.com/img/b/R29vZ2xl/AVvXsEg4a97QBZKUpAj8fDLzoFvnCKtjlVHNNCh8s9YPzjSKrKJXq4ewzDKWvdpIn3bE5PreL86mHAO3xDuPBg3zellWfvaLOMuA2KbzTFigEDnFp66aeo1O4ROkVvbMqNyj5gT_sVMV6kpTlfU/s640/resultadoFichero.jpg" width="640" /></a></div>
<br />MIPBhttp://www.blogger.com/profile/15144077089562468638noreply@blogger.com0tag:blogger.com,1999:blog-8606551171960007078.post-20656403981163903482016-02-07T11:51:00.001-08:002016-02-07T11:51:41.258-08:00Definir e Inicializar una variableEn esta entrada explicaré la diferencia entre Definir e Inicializar una variable, mucha veces se confunden los conceptos porque ambos se pueden realizar en una misma instrucción:<div>
<br /></div>
<div>
Ejemplo:</div>
<div>
int a = 0; </div>
<div>
<br /></div>
<div>
Aprendemos a crear variables de forma repetitiva y a veces es necesario saber la diferencia entre ambos conceptos para lograr una programación más limpia (no crear variables en exceso pudiendo reutilizarlas).</div>
<div>
<br /></div>
<div>
<b>Definir una variable</b></div>
<div>
Esto es <span style="color: blue;"><b>reservar un espacio</b></span> en la memoria para almacenar valores de un determinado tipo. Para definir una variable sólo es necesario saber el <b>tipo de la variable</b> y el <b>nombre </b>que queremos asignar.</div>
<div>
<br /></div>
<div>
Ejemplo:</div>
<div>
int a; <span style="color: #274e13;"><i>//int es el tipo y "a" es el nombre que he asignado a la variable.</i></span></div>
<div>
<br /></div>
<div>
Cuando realizamos esta instrucción, lo que hace el programa es reservar un espacio de memoria para la variable "a" del tamaño que marca el tipo (el tipo int puede ser de 2 bytes o 4 bytes dependiendo del procesador).</div>
<div>
<br /></div>
<div>
La variable "a" tiene un espacio para guardar valores, pero aún no hemos guardado nada en ese espacio.</div>
<div>
Podría ser que un anterior programa que utilizara ese mismo espacio de memoria, almacenara algún dato y luego al terminar de ejecutar dejara en ese espacio un valor, es importante que cada programe <span style="color: blue;"><b>limpie </b></span>los espacios reservados para sus variables.</div>
<div>
<br /></div>
<div>
<b>Inicializar una variable</b></div>
<div>
Esto es <span style="color: blue;"><b>limpiar </b></span>los espacios asignados a las variables en la definición para que queden preparados para trabajar con ellos. Para inicializar una variable utilizamos la <a href="http://ejemplosalgoritmos.blogspot.com.es/2013/02/instruccion-de-asignacion.html" target="_blank">instrucción de asignación</a>, asignando un valor fijo o el valor de otra variable.</div>
<div>
<br /></div>
<div>
Ejemplo:</div>
<div>
a = 0; <span style="color: #274e13;"><i>//inicializamos la variable "a" con un valor fijo</i></span></div>
<div>
int b; <i><span style="color: #274e13;">//definimos la variable "b"</span></i></div>
<div>
b = a; <i><span style="color: #274e13;">//inicializamos la variable "b" con el valor de la variable "a"</span></i></div>
<div>
<br /></div>
<div>
Sabiendo la diferencia entre Definir e Inicializar una variable, ahora si podemos simplificar ambas instrucciones en una sola:</div>
<div>
<br /></div>
<div>
Ejemplo:</div>
<div>
int a; <span style="color: #274e13;"><i>//Definir variable "a"</i></span></div>
<div>
a = 0; <span style="color: #274e13;"><i>//Inicializar variable "a"</i></span></div>
<div>
<b>int b = a; <span style="color: #274e13;">//Definir e Inicializar la variable "b" en una sola instrucción</span></b></div>
<div>
<br /></div>
<div>
<b>¿Cómo podemos reutilizar una variable sabiendo la diferencia entre Definir e Inicializar?</b></div>
<div>
Un ejemplo sencillo es imprimir un sucesión de números de forma creciente y de forma decreciente:</div>
<div>
<span style="color: #274e13;"><i>//Definimos una variable</i></span></div>
<div>
int numero;</div>
<div>
<span style="color: #274e13;"><i>//inicializamos el valor de la variable leyendo el valor desde consola</i></span></div>
<div>
scanf("%d",&numero);</div>
<div>
<span style="color: #274e13;"><i>//impresión decreciente</i></span></div>
<div>
for(int i=numero; i>0;i--) printf("%d",i);</div>
<div>
<span style="color: #274e13;"><i>//impresión creciente</i></span></div>
<div>
for(int i=0; i<=numero;i++) printf("%d",i);</div>
<div>
<br /></div>
<div>
La variable "i" definida en el primer for no es la misma variable definida en el segundo for, cada una existe sólo en el ámbito de cada for, pero podríamos hacer que sea una única variable y reutilizar en ambos bloques de instrucciones:</div>
<div>
<div>
<span style="color: #274e13;"><i>//Definimos una variable</i></span></div>
<div>
int numero;</div>
<div>
<span style="color: #274e13;"><i>//inicializamos el valor de la variable leyendo el valor desde consola</i></span></div>
<div>
scanf("%d",&numero);</div>
<div>
<span style="color: #274e13;"><i>//definimos e inicializamos la variable "i"</i></span></div>
<div>
int i = numero;</div>
<div>
<div>
<span style="color: #274e13;"><i>//impresión decreciente: no hace falta ni definir ni inicializar nuevamente la variable "i"</i></span></div>
<div>
for(; i>0;i--) printf("%d",i);</div>
<div>
<span style="color: #274e13;"><i>//impresión creciente: no hace falta ni definir ni inicializar nuevamente, el for anterior dejó la </i></span></div>
<div>
<span style="color: #274e13;"><i>//variable "i" en 0</i></span></div>
<div>
for(; i<=numero;i++) printf("%d",i);</div>
</div>
</div>
<div>
<br /></div>
<div>
<br /></div>
<div>
<br /></div>
<div>
<br /></div>
<div>
<br /></div>
<div>
<br /></div>
<div>
<br /></div>
<div>
<br /></div>
<div>
<br /></div>
<div>
<br /></div>
MIPBhttp://www.blogger.com/profile/15144077089562468638noreply@blogger.com0tag:blogger.com,1999:blog-8606551171960007078.post-61317982716318325362015-11-24T11:23:00.000-08:002015-11-24T11:23:37.079-08:00Palíndromo / CapicúaEl ejercicio de detectar si una secuencia de caracteres (o dígitos) es un <a href="https://es.wikipedia.org/wiki/Pal%C3%ADndromo" target="_blank">palíndromo </a>(<a href="https://es.wikipedia.org/wiki/Capic%C3%BAa" target="_blank">capicúa</a>) es uno de los ejercicios más completos, podemos ver: <a href="http://ejemplosalgoritmos.blogspot.com.es/2013/04/busqueda-con-recorrido-secuencial.html" target="_blank">recorrido de vectore</a>s, condicionales, uso de <a href="http://ejemplosalgoritmos.blogspot.com.es/2013/03/las-variables-booleanas.html" target="_blank">variables booleanas</a> y tratamiento de cadenas.<br />
<br />
Un ejemplo de palíndromo es la palabra "Radar", si la leemos de izquierda a derecha o viceversa leeremos lo mismo.<br />
<br />
<b>¿Cómo saber si es una palíndromo?</b><br />
Hacemos la lectura en un sentido y otro y comprobamos que decimos lo mismo, esta sería la versión resumida de lo que realmente hace nuestro cerebro. Pero si nos detenemos a pensar en cómo le diríamos al ordenador (procesador) que lo haga ¿cómo lo haríamos?<br />
Si leemos al mismo tiempo en ambas direcciones y comprobamos que cada letra que vamos leyendo es la misma, diríamos que <u>si todas y cada una de las letras que leemos en ambas direcciones son las mismas es un palíndromo</u>. En complemento a este razonamiento podemos decir también que en la comparación letra a letra que hacemos al leer una misma palabra en sentidos opuestos, <u>basta con que algún par difiera para que la palabra NO ses un palíndromo</u>.<br />
<br />
Dicho esto, es mucho más claro verlo en código comentado:<br />
<br />
<br />
<span style="font-family: 'Courier New', Courier, monospace;"><b><span style="color: #38761d;">//variable que almacena el texto (máximo 10 caracteres)</span></b></span><br />
<span style="font-family: Courier New, Courier, monospace;">char palabra[10]; </span><br />
<span style="font-family: Courier New, Courier, monospace;"><br /></span>
<span style="color: #38761d; font-family: Courier New, Courier, monospace;"><b>//variables para recorrer la palabra</b></span><br />
<span style="font-family: Courier New, Courier, monospace;">int indicePrimeraLetra = 0; <b><span style="color: #38761d;">//índice inicio recorrido de izq. a der.</span></b></span><br />
<span style="font-family: Courier New, Courier, monospace;">int indiceUltimaLetra; <b><span style="color: #38761d;">//índice inicio recorrido de der. a izq.</span></b></span><br />
<span style="font-family: Courier New, Courier, monospace;"><br /></span>
<span style="color: #38761d; font-family: Courier New, Courier, monospace;"><b>//variable que determina si la palabra es palíndromo</b></span><br />
<span style="font-family: Courier New, Courier, monospace;">bool esPalindromo = true;</span><br />
<span class="Apple-tab-span" style="white-space: pre;"><span style="font-family: Courier New, Courier, monospace;"> </span></span><br />
<span style="color: #38761d; font-family: Courier New, Courier, monospace;"><b>//llenamos el texto con información desde teclado</b></span><br />
<span style="font-family: Courier New, Courier, monospace;">printf("Ingresa la palabra: ");</span><br />
<span style="font-family: Courier New, Courier, monospace;">scanf ("%s",palabra);</span><br />
<span style="font-family: Courier New, Courier, monospace;">printf("\nLa palabra ingresada es: %s", palabra);</span><br />
<br />
<span style="color: #38761d; font-family: Courier New, Courier, monospace;"><b>//tratamiento de la cadena</b></span><br />
<span style="color: #38761d; font-family: Courier New, Courier, monospace;"><b>//inicializamos con la última posición para recorrer de der. a izq.</b></span><br />
<span style="font-family: Courier New, Courier, monospace;">indiceUltimaLetra = strlen(palabra) - 1;</span><br />
<span style="font-family: Courier New, Courier, monospace;">printf("\nNúmero de elementos de la palabra: %d", strlen(palabra));</span><br />
<span class="Apple-tab-span" style="white-space: pre;"><span style="font-family: Courier New, Courier, monospace;"> </span></span><br />
<span style="color: #38761d; font-family: Courier New, Courier, monospace;"><b>//realizamos la lectura en ambas direcciones, termina cuando se cruzan los índices o cuando alguna de las letras no coincide</b></span><br />
<span style="font-family: Courier New, Courier, monospace;">while(esPalindromo && indicePrimeraLetra < indiceUltimaLetra)</span><br />
<span style="font-family: Courier New, Courier, monospace;">{</span><br />
<span style="font-family: Courier New, Courier, monospace;"> <b><span style="color: #38761d;">//basta que un par de letras no coincida para que NO sea palíndromo</span></b></span><br />
<span style="font-family: 'Courier New', Courier, monospace;"> if (palabra[indicePrimeraLetra] != palabra[indiceUltimaLetra])</span><br />
<span style="font-family: Courier New, Courier, monospace;"> {esPalindromo = false;}</span><br />
<span style="font-family: Courier New, Courier, monospace;"> </span><br />
<span style="font-family: 'Courier New', Courier, monospace;"> indicePrimeraLetra++;<b><span style="color: #38761d;">//incrementa índice lectura izq. a der.</span></b></span><br />
<span style="font-family: Courier New, Courier, monospace;"> indiceUltimaLetra--;<b><span style="color: #38761d;">//decrementa índice lectura der. a izq.</span></b></span><br />
<span style="font-family: Courier New, Courier, monospace;">}</span><br />
<span class="Apple-tab-span" style="white-space: pre;"><span style="font-family: Courier New, Courier, monospace;"> </span></span><br />
<span class="Apple-tab-span" style="white-space: pre;"><span style="font-family: Courier New, Courier, monospace;"> </span></span><br />
<span style="font-family: Courier New, Courier, monospace;">printf("\n¿Es palindromo? ");</span><br />
<span style="font-family: Courier New, Courier, monospace;">if(esPalindromo) printf("SI");</span><br />
<span style="font-family: Courier New, Courier, monospace;">else printf("NO");</span><br />
<span class="Apple-tab-span" style="white-space: pre;"><span style="font-family: Courier New, Courier, monospace;"> </span></span><br />
<br />
<b>Importante!!</b><br />
- La inicialización de la variable indiceUltimaLetra se hace después de leer la palabra a evaluar, porque tiene que posicionarse en la última letra y hasta no leer la palabra no sabemos la longitud.<br />
- La dirección del recorrido de las lecturas se determina al incrementar la variable indicePrimeraLetra y al decrementar la variable indiceUltimaLetra<br />
- La condición de salida del while: Si sale por la primera condición es que la palabra NO es un palíndromo, si sale por la segunda condición ha terminado de comprobar y todas coinciden por tanto SI es palindromo.<br />
<br />
Finalmente...<br />
<i>¿Sabéis por qué el recorrido termina a la mitad de la palabra (condición indicePrimeraLetra < indiceUltimaLetra) y por que no cuando indicePrimeraLetra llega hasta el final de la palabra (strlen(palabra))?</i><br />
<br />
<br />
<br />
<br />
<br />MIPBhttp://www.blogger.com/profile/15144077089562468638noreply@blogger.com0tag:blogger.com,1999:blog-8606551171960007078.post-14366058658593705572015-11-05T09:26:00.002-08:002015-11-05T09:27:46.391-08:00Asignación (=) VS. Comparación (==)Un error típico es confundir la operación lógica de comparación IGUAL con la de <a href="http://ejemplosalgoritmos.blogspot.com.es/2013/02/instruccion-de-asignacion.html" target="_blank">asignación</a>, lo peor de este error es que no se detecta en la compilación ni en la ejecución, sino que genera que el programa realice un flujo diferente al esperado.<br />
<br />
La operación de asignación (=) cuando se realiza correctamente devuelve un 1 como resultado indicando que todo ha ido bien, por ejemplo:<br />
<br />
<span style="font-family: "courier new" , "courier" , monospace; font-size: xx-small;">int a; <span style="color: #38761d;"><b>//definición de variable a de tipo int</b></span></span><br />
<span style="font-family: "courier new" , "courier" , monospace; font-size: xx-small;">if( a = 3) <span style="color: #38761d;"><b>//si la operación de asignación se realiza correctamente realiza lo que está dentro del if</b></span></span><br />
<span style="font-family: "courier new" , "courier" , monospace; font-size: xx-small;">{</span><br />
<span style="font-family: "courier new" , "courier" , monospace; font-size: xx-small;"> ...</span><br />
<span style="font-family: "courier new" , "courier" , monospace; font-size: xx-small;">}</span><br />
<br />
Podría ocurrir que por un error físico o lógico de memoria la operación a=3 se realice mal, en ese caso no se realizaría lo que está dentro del if.<br />
<br />
Un ejemplo típico es utilizar variables para determinar el fin de una iteración, como ejemplo tenemos un programa que realiza una operativa siempre que el usuario pulse 1, cuando el usuario marca una tecla distinta termina la ejecución del programa. La estructura del algoritmo sería la siguiente:<br />
<br />
<span style="font-family: "courier new" , "courier" , monospace; font-size: xx-small;">int fin_ejecucion = 1; <b><span style="color: #38761d;">//variable que determina el fin de la ejecución del programa</span></b></span><br />
<span style="font-family: "courier new" , "courier" , monospace; font-size: xx-small;"><br /></span>
<span style="font-family: "courier new" , "courier" , monospace; font-size: xx-small;">while (fin_ejecucion == 1)</span><br />
<span style="font-family: "courier new" , "courier" , monospace; font-size: xx-small;">{</span><br />
<b><span style="color: #38761d; font-family: "courier new" , "courier" , monospace; font-size: xx-small;"> //aquí realiza la función del programa</span></b><br />
<b><span style="color: #38761d; font-family: "courier new" , "courier" , monospace; font-size: xx-small;"> //cuando termina la ejecución pregunta si quiere continuar</span></b><br />
<span style="font-family: "courier new" , "courier" , monospace; font-size: xx-small;"> write("Pulse 1 si desea continuar");</span><br />
<span style="font-family: "courier new" , "courier" , monospace; font-size: xx-small;"> read(fin_ejecucion); <b><span style="color: #38761d;">//lee del teclado lo que el usuario quiere</span></b></span><br />
<span style="font-family: "courier new" , "courier" , monospace; font-size: xx-small;">}</span><br />
<br />
Si por error, cambiásemos la comparación por la asignación, la consecuencia sería que la operación fin_ejecucion = 1 siempre sería TRUE y por tanto nunca dejará de ejecutar el bucle.<br />
<br />
Parece trivial, cuando en resolución de ejercicios (sobretodo los que se hacen en papel), se insiste mucho sobre este tema, pero es muy importante tenerlo en cuenta debido a que el compilador no lo puede detectar (no es un error de sintaxis) y tampoco lanza error en tiempo de ejecución, simplemente el programa hace algo que no le hemos pedido.<br />
<br />
En otros lenguajes de programación como el PLSQL es más difícil caer en este error porque la instrucción de asignación se representa con <b>:=</b> y la de comparación con <b>=</b>, por esto es importante conocer el set de instrucciones básicas (<a href="http://ejemplosalgoritmos.blogspot.com.es/2013/03/las-variables-booleanas.html" target="_blank">lógicas </a>y aritméticas) antes de empezar a programar.<br />
<br />
<br />
<br />
<br />
<br />MIPBhttp://www.blogger.com/profile/15144077089562468638noreply@blogger.com0tag:blogger.com,1999:blog-8606551171960007078.post-79528905039513832562015-10-25T03:46:00.000-07:002015-10-25T03:46:09.887-07:00Operación Residuo (MOD)<div lang="es-ES" style="margin-bottom: 0cm;">
El set de instrucciones de
cada lenguaje de programación puede llegar a ser tan amplio que no
llegamos a aprenderlo todo y mucho menos saber en qué casos podemos
sacar ventaja de utilizar una instrucción determinada.</div>
<div lang="es-ES" style="margin-bottom: 0cm;">
En este post quiero
hablar de la instrucción de <span style="color: navy;"><b>Residuo</b></span>,
conocida como <span style="color: navy;"><b>%</b></span> en C, C++, php,
java o <span style="color: navy;"><b>MOD</b></span> en COBOL, PLSQL,
Pascal.</div>
<div lang="es-ES" style="margin-bottom: 0cm;">
<br />
</div>
<div lang="es-ES" style="margin-bottom: 0cm;">
Recordando un poco de
matemáticas, sabemos que:
</div>
<div lang="es-ES" style="margin-bottom: 0cm;">
Dividendo = Cociente *
Divisor + Residuo</div>
<div lang="es-ES" style="margin-bottom: 0cm;">
Ejm. 7 = 3 * 2 + 1</div>
<div lang="es-ES" style="margin-bottom: 0cm;">
Si despejamos el residuo
sería:</div>
<div lang="es-ES" style="margin-bottom: 0cm;">
Residuo = Dividendo -
(Cociente * Divisor)</div>
<div lang="es-ES" style="margin-bottom: 0cm;">
<br />
</div>
<div lang="es-ES" style="margin-bottom: 0cm;">
La operación Residuo se
calcula utilizando el Dividendo y el cociente o el dividendo y el
divisor. La sintaxis sería:</div>
<div lang="es-ES" style="margin-bottom: 0cm;">
Residuo = Dividendo %
Cociente (1 = 7 % 3)</div>
<div lang="es-ES" style="margin-bottom: 0cm;">
Residuo = Dividendo %
Divisor (1 = 7 % 2)</div>
<div lang="es-ES" style="margin-bottom: 0cm;">
<br />
</div>
<div lang="es-ES" style="margin-bottom: 0cm;">
¿En qué casos podemos
utilizar esta operación?</div>
<div lang="es-ES" style="margin-bottom: 0cm;">
Sólo os daré dos casos típicos:</div>
<div lang="es-ES" style="margin-bottom: 0cm;">
<br /></div>
<div lang="es-ES" style="margin-bottom: 0cm;">
<span style="color: navy;"><b>Realizar
una acción cuando un número es múltiplo de otro</b></span></div>
<div lang="es-ES" style="margin-bottom: 0cm;">
<span style="color: black;">Imprimir
los 30 primeros múltiplos de 3</span></div>
<div lang="es-ES" style="margin-bottom: 0cm;">
<span style="color: black;">int
numerosImpresos = 0 </span><span style="color: #38761d;"><b>//controla el número de números impresos</b></span></div>
<div lang="es-ES" style="margin-bottom: 0cm;">
<span style="color: black;">int
contador = 1; </span><span style="color: #38761d;"><b>//Es el número que hace de Dividendo en la operación</b></span></div>
<div lang="es-ES" style="margin-bottom: 0cm;">
<span style="color: black;">while(numerosImpresos
< 30)</span></div>
<div lang="es-ES" style="margin-bottom: 0cm;">
<span style="color: black;">{
</span>
</div>
<div lang="es-ES" style="margin-bottom: 0cm;">
if (contador % 3 == 0) <b><span style="color: #38761d;">//si el residuo es 0, es una división exacta por tanto es múltiplo</span></b></div>
<div lang="es-ES" style="margin-bottom: 0cm;">
<span style="color: black;"> {</span></div>
<div lang="es-ES" style="margin-bottom: 0cm;">
<span style="color: black;"> Console.write(contador); </span></div>
<div lang="es-ES" style="margin-bottom: 0cm;">
<span style="color: black;"> }</span></div>
<div lang="es-ES" style="margin-bottom: 0cm;">
<span style="color: black;"> contador ++;</span></div>
<div lang="es-ES" style="margin-bottom: 0cm;">
<span style="color: black;">}</span></div>
<div lang="es-ES" style="margin-bottom: 0cm;">
<span style="color: black;"><br /></span></div>
<div lang="es-ES" style="margin-bottom: 0cm;">
<span style="color: navy;"><b>Realizar
un cambio de base</b></span></div>
<div lang="es-ES" style="margin-bottom: 0cm;">
<span style="color: black;">Cambiar
el número 5 de base decimal a binario.</span></div>
<div lang="es-ES" style="margin-bottom: 0cm;">
<span style="color: black;">Como
se cambia a sistema binario de utiliza el divisor = 2 (Base N,
implica divisor N)</span></div>
<div lang="es-ES" style="margin-bottom: 0cm;">
<br />
</div>
<div lang="es-ES" style="margin-bottom: 0cm;">
<span style="color: black;">int
dividendo = 5;</span></div>
<div lang="es-ES" style="margin-bottom: 0cm;">
<span style="color: black;">int
divisor = 2;</span></div>
<div lang="es-ES" style="margin-bottom: 0cm;">
<span style="color: black;">string
cambioBase = “”;</span></div>
<div lang="es-ES" style="margin-bottom: 0cm;">
<br />
</div>
<div lang="es-ES" style="margin-bottom: 0cm;">
<span style="color: black;">while(dividendo
/ divisor >1)</span></div>
<div lang="es-ES" style="margin-bottom: 0cm;">
<span style="color: black;">{</span></div>
<div lang="es-ES" style="margin-bottom: 0cm;">
<span style="color: black;"> residuo = dividendo % divisor;</span></div>
<div lang="es-ES" style="margin-bottom: 0cm;">
<span style="color: black;"> dividendo = dividendo / divisor;</span></div>
<div lang="es-ES" style="margin-bottom: 0cm;">
cambioBase = residuo + cambioBase;<b><span style="color: #38761d;"> //se va concatenando a la izquierda</span></b></div>
<div lang="es-ES" style="margin-bottom: 0cm;">
<span style="color: black;">}</span></div>
<div lang="es-ES" style="margin-bottom: 0cm;">
<span style="color: black;">cambioBase
= dividendo + cambioBase; </span><span style="color: #38761d;"><b>//en esta variable está el resultado "101"</b></span></div>
<div lang="es-ES" style="margin-bottom: 0cm;">
<span style="color: black;"><br /></span></div>
<div lang="es-ES" style="margin-bottom: 0cm;">
<span style="color: black;"><br /></span></div>
<div lang="es-ES" style="margin-bottom: 0cm;">
<span style="color: black;"><br /></span></div>
<div lang="es-ES" style="margin-bottom: 0cm;">
<span style="color: black;">¿Se os ocurre otro ejemplo?</span></div>
<div lang="es-ES" style="margin-bottom: 0cm;">
<span style="color: black;"><br /></span></div>
<div lang="es-ES" style="margin-bottom: 0cm;">
<span style="color: black;"><br /></span></div>
<div lang="es-ES" style="margin-bottom: 0cm;">
<span style="color: black;"><br /></span></div>
<div lang="es-ES" style="margin-bottom: 0cm;">
<span style="color: black;"><br /></span></div>
<div lang="es-ES" style="margin-bottom: 0cm;">
<span style="color: black;"><br /></span></div>
<div lang="es-ES" style="margin-bottom: 0cm;">
<span style="color: black;"><br /></span></div>
MIPBhttp://www.blogger.com/profile/15144077089562468638noreply@blogger.com2tag:blogger.com,1999:blog-8606551171960007078.post-5301214390663649502015-09-01T11:08:00.000-07:002015-09-01T11:08:03.591-07:00El mejor algoritmo<div style="text-align: justify;">
Este post está dedicado a una persona que quiero mucho y que a pesar que cambió la informática por la economía, aún tiene un bichito informático dentro que se pregunta: ¿cómo saber si un algoritmo es mejor que otro? </div>
<div style="text-align: justify;">
La respuesta es el clásico "depende":</div>
<div style="text-align: justify;">
- Depende de los datos, en algunos casos a medida que se evalúan más datos el algoritmo se va degradando, porque la función del rendimiento es exponencial por ejemplo.</div>
<div style="text-align: justify;">
- Depende de la arquitectura, en algunos casos el procesador está preparado para soportar operaciones más complejas en menor número de instrucciones.</div>
<div style="text-align: justify;">
- Depende del objetivo, en algunos casos se puede hacer un algoritmo muy complejo y casi ininteligible, con lo que a otro programador le costaría mucho entenderlo como para probarlo o modificarlo, se debe tener siempre en consideración que además de apoyarnos en buenos comentarios en el código y nombres de variables que ayuden a la comprensión, el código en sí, si es para uso masivo y cualquiera puede modificarlo no debería ser tan complejo, sin embargo si es un código cerrado, se puede elevar la complejidad.</div>
<div style="text-align: justify;">
<br /></div>
<div style="text-align: justify;">
Existen más variables que hacen que un algoritmo sea mejor o peor que otro, pero en este post quería centrarme estrictamente en la función de rendimiento que nos puede ayudar a hacer comparaciones entre diferentes soluciones.</div>
<br />
Para entender mejor esto del rendimiento, trataremos el cálculo del factorial de un número:<br />
<br />
<b>Problema:</b> Calcular el Factorial de N, donde N es un numero Natural >= 1<br />
<b>Supuestos:</b><br />
1) Cada instrucción tarda una unidad de tiempo T<br />
2) No consideraremos el tiempo en que se reserva memoria en la función recursiva<br />
<br />
<b>Propuesta 1 de Factorial</b><br />
<span style="font-family: Courier New, Courier, monospace;">Función FactorialIterativa(N)</span><br />
<span style="font-family: Courier New, Courier, monospace;"> F = N; <span style="color: red;">--> T</span></span><br />
<span style="font-family: Courier New, Courier, monospace;"> <span style="color: #38761d;">//la variable i va desde N-1 hasta 1 y es la que se va multiplicando</span></span><br />
<span style="font-family: Courier New, Courier, monospace;"> i = N - 1; <span style="color: red;">--> T</span> </span><br />
<span style="font-family: Courier New, Courier, monospace;"> Mientras (i > 1) <span style="color: red;">--> La comparación se realiza N-1 veces: T * (N-1)</span></span><br />
<span style="font-family: Courier New, Courier, monospace;"> F = F * i; <span style="color: red;">--> La comparación se realiza N-2 veces: T * (N-2)</span></span><br />
<span style="font-family: Courier New, Courier, monospace;"> i = i - 1; <span style="color: red;">--> La comparación se realiza N-2 veces: T * (N-2)</span></span><br />
<span style="font-family: Courier New, Courier, monospace;"> Fin_Para</span><br />
<span style="font-family: Courier New, Courier, monospace;"> Return F; <span style="color: red;">--> T</span> </span><br />
<span style="font-family: Courier New, Courier, monospace;">Fin_Función</span><br />
Tiempo Total = <span style="color: red;">T + T + T</span><span style="color: red;"> * (N-1) + </span><span style="color: red;">T * (N-2) + </span><span style="color: red;">T * (N-2) + T = <b>(3N - 2) T</b></span><br />
<br />
<b>Propuesta 2 de Factorial</b><br />
<div>
<span style="font-family: Courier New, Courier, monospace;">Funcion FactorialRecursiva (N)</span></div>
<div>
<span style="font-family: Courier New, Courier, monospace;"> Si N = 1 <span style="color: red;">--> Cada vez que se llama a la recursiva se hace la comparación, por tanto se hace N veces. N * T</span></span></div>
<div>
<span style="font-family: Courier New, Courier, monospace;"> Return N <span style="color: red;">--> Esta se hace sólo una vez, la última. T</span></span></div>
<div>
<span style="font-family: Courier New, Courier, monospace;"> Caso Contrario</span></div>
<div>
<span style="font-family: Courier New, Courier, monospace;"> Return N * FactorialRecursiva(N-1)<span style="color: red;"> --> Se ejecuta N - 1 veces. (N - 1) * T</span></span></div>
<div>
<span style="font-family: Courier New, Courier, monospace;"> Fin_Si</span></div>
<div>
<span style="font-family: Courier New, Courier, monospace;">Fin_Funcion</span></div>
<div>
Tiempo Total = <span style="color: red;">N * T + T + (N-1) * T = <b>2N * T</b></span></div>
<div>
<span style="color: red;"><b><br /></b></span></div>
<div>
<b><span style="color: blue;">Con estas funciones de rendimiento, podríamos decir que para los supuestos considerados y para N > 2, la propuesta 2 tiene mejor rendimiento que la propuesta 1.</span></b></div>
<div>
<b><span style="color: blue;"><br /></span></b></div>
<div>
Con esto logramos tener una herramienta simple para comparar algoritmos, siempre bajo supuestos. </div>
<div>
Sería muy difícil contemplar todas las variables que intervienen, pero podemos aproximarnos y nos puede servir para optar por algún algoritmo u otro. </div>
<div>
<br /></div>
MIPBhttp://www.blogger.com/profile/15144077089562468638noreply@blogger.com0tag:blogger.com,1999:blog-8606551171960007078.post-30215955062051989532015-07-04T05:04:00.004-07:002015-07-04T05:09:12.603-07:00Juego: Tres en raya<div style="margin-bottom: 0cm;">
<div class="separator" style="clear: both; text-align: center;">
<a href="https://upload.wikimedia.org/wikipedia/commons/thumb/3/32/Tic_tac_toe.svg/245px-Tic_tac_toe.svg.png" imageanchor="1" style="margin-left: 1em; margin-right: 1em;"><img border="0" src="https://upload.wikimedia.org/wikipedia/commons/thumb/3/32/Tic_tac_toe.svg/245px-Tic_tac_toe.svg.png" /></a></div>
<br />
<br />
Esta vez repasaremos matrices,
funciones, condicionales e iteraciones, todo
esto aplicado en el clásico juego del tres en raya, las reglas del
juego son muy conocidas, sólo haré unos cuantos razonamientos
previos antes de empezar a programar:</div>
<div style="margin-bottom: 0cm;">
<br /></div>
<div style="margin-bottom: 0cm;">
<h2>
<b>Sobre los turnos</b></h2>
</div>
<div style="margin-bottom: 0cm;">
Sabemos que son 2 jugadores que juegan
por turnos <i><b>hasta</b></i> que alguno gana o el tablero se llena
sin ganador (situación de empate).
</div>
<div style="margin-bottom: 0cm;">
Vemos que debe existir una <a href="http://ejemplosalgoritmos.blogspot.com.es/2013/03/lo-que-no-debemos-olvidar-en-una.html" target="_blank">iteración</a> que finalice cuando el juego termina:</div>
<div style="margin-bottom: 0cm;">
<br /></div>
<div style="margin-bottom: 0cm;">
var fin_juego = false;</div>
<div style="margin-bottom: 0cm;">
var turno = 0; <span style="color: #38761d;">//los jugadores son 0 y
1</span></div>
<div style="margin-bottom: 0cm;">
<br /></div>
<div style="margin-bottom: 0cm;">
while(<b>!</b>fin_juego)</div>
<div style="margin-bottom: 0cm;">
{</div>
<div style="margin-bottom: 0cm;">
<span style="color: #38761d;"> //se hace la jugada</span></div>
<div style="margin-bottom: 0cm;">
<span style="color: #38761d;"> //si se gana en este turno fin_juego
= true;</span></div>
<div style="margin-bottom: 0cm;">
<span style="color: #38761d;"> //si el tablero se llena sin ganador
fin_juego = true;</span></div>
<div style="margin-bottom: 0cm;">
</div>
<div style="margin-bottom: 0cm;">
turno = (turno + 1) % 2; //esto es
para cambiar el turno de 0 a 1 y de 1 a 0</div>
<div style="margin-bottom: 0cm;">
}</div>
<div style="margin-bottom: 0cm;">
<br />
<div class="separator" style="clear: both; text-align: center;">
<a href="https://upload.wikimedia.org/wikipedia/commons/d/db/Tic-tac-toe-game-2.png" imageanchor="1" style="margin-left: 1em; margin-right: 1em;"><img border="0" height="81" src="https://upload.wikimedia.org/wikipedia/commons/d/db/Tic-tac-toe-game-2.png" width="640" /></a></div>
<br />
<br /></div>
<div style="margin-bottom: 0cm;">
Sabemos que es un tablero de 9 casillas
(3 filas y 3 columnas). En principio todas las casillas están vacías
y en cada turno se va llenando alguna de las casillas con la jugada
hecha en el turno.</div>
<div style="margin-bottom: 0cm;">
Si todas las casillas están llenas y
no hay ganador, entonces es un empate.</div>
<div style="margin-bottom: 0cm;">
Para controlar que el juego termine en
empate creamos un <a href="http://ejemplosalgoritmos.blogspot.com.es/2013/03/las-variables-booleanas.html" target="_blank"><b>condicional</b> </a>en cada iteración que controle
si se llenó el tablero o no.</div>
<div style="margin-bottom: 0cm;">
<br /></div>
<div style="margin-bottom: 0cm;">
var fin_juego = false;</div>
<div style="margin-bottom: 0cm;">
var turno = 0; <span style="color: #38761d;">//los jugadores son 0 y
1</span></div>
<div style="margin-bottom: 0cm;">
<b>var casillas_vacias = 9;</b></div>
<div style="margin-bottom: 0cm;">
<br /></div>
<div style="margin-bottom: 0cm;">
while(<b>!</b>fin_juego)</div>
<div style="margin-bottom: 0cm;">
{</div>
<div style="margin-bottom: 0cm;">
<span style="color: #38761d;"> //se hace la jugada</span></div>
<div style="margin-bottom: 0cm;">
<b> casillas_vacias = casillas_vacias -
1; </b><span style="color: #38761d;">//al hacer la jugada disminuye en 1 las casillas vacías</span></div>
<div style="margin-bottom: 0cm;">
<span style="color: #38761d;"><br />
</span></div>
<div style="margin-bottom: 0cm;">
<span style="color: #38761d;"> //si se gana en este turno fin_juego
= true;</span></div>
<div style="margin-bottom: 0cm;">
<span style="color: #38761d;"><br />
</span></div>
<div style="margin-bottom: 0cm;">
<span style="color: #38761d;"> //si el tablero se llena sin ganador
fin_juego = true;</span></div>
<div style="margin-bottom: 0cm;">
<b> if(!fin_juego &&
casillas_vacias == 0) fin_juego = true;</b></div>
<div style="margin-bottom: 0cm;">
</div>
<div style="margin-bottom: 0cm;">
turno = (turno + 1) % 2; <span style="color: #38761d;">//esto es
para cambiar el turno de 0 a 1 y de 1 a 0</span></div>
<div style="margin-bottom: 0cm;">
}</div>
<div style="margin-bottom: 0cm;">
<br /></div>
<div style="margin-bottom: 0cm;">
<h2>
<b>Sobre la jugada</b></h2>
</div>
<div style="margin-bottom: 0cm;">
El jugador debe seleccionar la casilla
que quiere marcar, para esto utilizaremos las filas y las columnas de
la <a href="http://ejemplosalgoritmos.blogspot.com.es/2014/07/algo-de-matrices.html" target="_blank"><b>matriz</b> </a>que representa al tablero.</div>
<div style="margin-bottom: 0cm;">
<br /></div>
<div style="margin-bottom: 0cm;">
var boolean fin_juego = false;</div>
<div style="margin-bottom: 0cm;">
var int turno = 0; <span style="color: #38761d;">//los jugadores son
0 y 1</span></div>
<div style="margin-bottom: 0cm;">
var int casillas_vacias = 9;</div>
<div style="margin-bottom: 0cm;">
<b>var char tablero [3][3];<span style="color: #38761d;">//matriz de 3 x
3 que representa al tablero</span></b></div>
<div style="margin-bottom: 0cm;">
<b>var int fila_jugada;</b></div>
<div style="margin-bottom: 0cm;">
<b>var int columna_jugada;</b></div>
<div style="margin-bottom: 0cm;">
<b>var char ficha='0'; <span style="color: #38761d;">//será 'X' cuando
el turno sea 1</span></b></div>
<div style="margin-bottom: 0cm;">
<br /></div>
<div style="margin-bottom: 0cm;">
while(<b>!</b>fin_juego)</div>
<div style="margin-bottom: 0cm;">
{</div>
<div style="margin-bottom: 0cm;">
<span style="color: #38761d;"><b> //se hace la jugada</b></span></div>
<div style="margin-bottom: 0cm;">
<b> fila_jugada = leer(); <span style="color: #38761d;">//lee de
consola la fila (de 0 a 2) que selecciona el jugador en ese turno</span></b></div>
<div style="margin-bottom: 0cm;">
<b> columna_jugada = leer(); <span style="color: #38761d;">//lee de
consola la columna (de 0 a 2) que selecciona el jugador en ese turno</span></b></div>
<div style="margin-bottom: 0cm;">
<b> if(turno == 0) ficha = '0'; <span style="color: #38761d;">//escoge
ficha</span></b></div>
<div style="margin-bottom: 0cm;">
<b> else ficha = 'X';</b></div>
<div style="margin-bottom: 0cm;">
<b> tablero[fila_jugada][columna_jugada]
= ficha;</b></div>
<div style="margin-bottom: 0cm;">
<b> casillas_vacias = casillas_vacias -
1; <span style="color: #38761d;">//al hacer la jugada disminuye en 1 las casillas vacías</span></b></div>
<div style="margin-bottom: 0cm;">
<span style="color: #38761d;"><br />
</span></div>
<div style="margin-bottom: 0cm;">
<span style="color: #38761d;"> //si se gana en este turno fin_juego
= true;</span></div>
<div style="margin-bottom: 0cm;">
<br /></div>
<div style="margin-bottom: 0cm;">
<span style="color: #38761d;"> //si el tablero se llena sin ganador
fin_juego = true;</span></div>
<div style="margin-bottom: 0cm;">
if(<b>!</b>fin_juego &&
casillas_vacias == 0) fin_juego = true;</div>
<div style="margin-bottom: 0cm;">
</div>
<div style="margin-bottom: 0cm;">
turno = (turno + 1) % 2; <span style="color: #38761d;">//esto es
para cambiar el turno de 0 a 1 y de 1 a 0</span></div>
<div style="margin-bottom: 0cm;">
}</div>
<div style="margin-bottom: 0cm;">
<br /></div>
<div style="margin-bottom: 0cm;">
<h2>
<b>Sobre el control de la jugada ganadora</b></h2>
</div>
<div style="margin-bottom: 0cm;">
Cuando se coloca la ficha se hace
control en vertical, horizontal y diagonales a ver si es una jugada
ganadora.</div>
<div style="margin-bottom: 0cm;">
Para el control horizontal, todas las
fichas de la fila_jugada deben ser iguales, por tanto haremos una
validación iterando las columnas.</div>
<div style="margin-bottom: 0cm;">
Para el control vertical, todas las
fichas de la columna_jugada deben ser iguales, por tanto haremos una
validación iterando las filas.</div>
<div style="margin-bottom: 0cm;">
Para el control diagonal, no es
necesario realizarlo siempre, sólo cuando la jugada esté en alguna
diagonal. Y sólo si está en el medio del tablero la comprobación
debe ser de la doble diagonal.
</div>
<div style="margin-bottom: 0cm;">
Comprobar diagonal 1</div>
<div style="margin-bottom: 0cm;">
fila_jugada: 0 y columna_jugada:0,
</div>
<div style="margin-bottom: 0cm;">
fila_jugada: 2 y columna_jugada:2</div>
<div style="margin-bottom: 0cm;">
<br /></div>
<div style="margin-bottom: 0cm;">
Comprobar diagonal 2</div>
<div style="margin-bottom: 0cm;">
fila_jugada: 2 y columna_jugada:0,
</div>
<div style="margin-bottom: 0cm;">
fila_jugada: 0 y columna_jugada:2</div>
<div style="margin-bottom: 0cm;">
<br /></div>
<div style="margin-bottom: 0cm;">
Comprobar ambas diagonales.</div>
<div style="margin-bottom: 0cm;">
fila_jugada: 1 y columna_jugada:1</div>
<div style="margin-bottom: 0cm;">
<br />
<div class="separator" style="clear: both; text-align: center;">
<a href="https://upload.wikimedia.org/wikipedia/commons/e/e1/Tic-tac-toe-game-1.png" imageanchor="1" style="margin-left: 1em; margin-right: 1em;"><img border="0" height="106" src="https://upload.wikimedia.org/wikipedia/commons/e/e1/Tic-tac-toe-game-1.png" width="640" /></a></div>
<br />
<br /></div>
<div style="margin-bottom: 0cm;">
Como esta lógica es un poco larga, la
encapsularemos en una <a href="http://ejemplosalgoritmos.blogspot.com.es/2013/01/por-donde-empiezo.html" target="_blank"><b>función</b> </a>y la utilizaremos en cada
jugada para comprobar si la jugada es ganadora:</div>
<div style="margin-bottom: 0cm;">
<br /></div>
<div style="margin-bottom: 0cm;">
<b>Entrada:</b> ¿Qué necesito?</div>
<div style="margin-bottom: 0cm;">
Tablero, fila_jugada, columna_jugada</div>
<div style="margin-bottom: 0cm;">
<b>Salida: </b>¿Qué quiero?</div>
<div style="margin-bottom: 0cm;">
Booleano que indique si es una jugada
ganadora o no</div>
<div style="margin-bottom: 0cm;">
<b>Función: </b>¿Cómo lo hago?</div>
<div style="margin-bottom: 0cm;">
Comprobando la Horizontal, Vertical y
cuando toque las diagonales.</div>
<div style="margin-bottom: 0cm;">
<br /></div>
<div style="margin-bottom: 0cm;">
Boolean esGanador(tablero, fila_jugada,
columna_jugada)</div>
<div style="margin-bottom: 0cm;">
{</div>
<div style="margin-bottom: 0cm;">
Boolean jugada_ganadora = false;</div>
<div style="margin-bottom: 0cm;">
<span style="color: #38761d;"> //validación horizontal</span> </div>
<div style="margin-bottom: 0cm;">
if(Tablero[fila_jugada][0] ==
Tablero[fila_jugada][1] &&
</div>
<div style="margin-bottom: 0cm;">
Tablero[fila_jugada][0] ==
Tablero[fila_jugada][2])</div>
<div style="margin-bottom: 0cm;">
{</div>
<div style="margin-bottom: 0cm;">
return true; <span style="color: #38761d;">//jugada ganadora en
la horizontal, termina la ejecución</span></div>
<div style="margin-bottom: 0cm;">
}</div>
<div style="margin-bottom: 0cm;">
<span style="color: #38761d;"> //validación vertical</span> </div>
<div style="margin-bottom: 0cm;">
if(Tablero[0][columna_jugada] ==
Tablero[1][columna_jugada] &&
</div>
<div style="margin-bottom: 0cm;">
Tablero[0][columna_jugada] ==
Tablero[2][columna_jugada])</div>
<div style="margin-bottom: 0cm;">
{</div>
<div style="margin-bottom: 0cm;">
return true; <span style="color: #38761d;">//jugada ganadora en
la vertical, termina la ejecución</span></div>
<div style="margin-bottom: 0cm;">
}</div>
<div style="margin-bottom: 0cm;">
<span style="color: #38761d;"> //verifica la diagonal 1 (sólo si es
necesario)</span></div>
<div style="margin-bottom: 0cm;">
if( (fila_jugada == 0 &&
columna_jugada == 0) || (fila_jugada == 2 && columna_jugada
== 2))</div>
<div style="margin-bottom: 0cm;">
{</div>
<div style="margin-bottom: 0cm;">
if(Tablero[0][0] == Tablero[1][1] &&
</div>
<div style="margin-bottom: 0cm;">
Tablero[0][0] == Tablero[2][2])</div>
<div style="margin-bottom: 0cm;">
{</div>
<div style="margin-bottom: 0cm;">
return true;<span style="color: #38761d;"> //jugada ganadora en
la diagonal 1, termina la ejecución</span></div>
<div style="margin-bottom: 0cm;">
}</div>
<div style="margin-bottom: 0cm;">
}</div>
<div style="margin-bottom: 0cm;">
<br /></div>
<div style="margin-bottom: 0cm;">
<span style="color: #38761d;"> //verifica la diagonal 2 (sólo si es
necesario)</span></div>
<div style="margin-bottom: 0cm;">
if( (fila_jugada == 0 &&
columna_jugada == 2) || (fila_jugada == 2 && columna_jugada
== 0))</div>
<div style="margin-bottom: 0cm;">
{</div>
<div style="margin-bottom: 0cm;">
if(Tablero[0][2] == Tablero[1][1] &&
</div>
<div style="margin-bottom: 0cm;">
Tablero[0][2] == Tablero[2][0])</div>
<div style="margin-bottom: 0cm;">
{</div>
<div style="margin-bottom: 0cm;">
return true; <span style="color: #38761d;">//jugada ganadora en
la diagonal 2, termina la ejecución</span></div>
<div style="margin-bottom: 0cm;">
}</div>
<div style="margin-bottom: 0cm;">
}</div>
<div style="margin-bottom: 0cm;">
<br /></div>
<div style="margin-bottom: 0cm;">
<span style="color: #38761d;"> //verifica la doble diagonal(sólo si
es necesario)</span></div>
<div style="margin-bottom: 0cm;">
if( fila_jugada == 1 &&
columna_jugada == 1)</div>
<div style="margin-bottom: 0cm;">
{</div>
<div style="margin-bottom: 0cm;">
if((Tablero[0][2] == Tablero[1][1] &&
</div>
<div style="margin-bottom: 0cm;">
Tablero[0][2] == Tablero[2][0])
||</div>
<div style="margin-bottom: 0cm;">
(Tablero[0][0] == Tablero[1][1] &&
</div>
<div style="margin-bottom: 0cm;">
Tablero[0][0] == Tablero[2][2]))</div>
<div style="margin-bottom: 0cm;">
{</div>
<div style="margin-bottom: 0cm;">
return true; <span style="color: #38761d;">//jugada ganadora en
alguna de las diagonales, termina la ejecución</span></div>
<div style="margin-bottom: 0cm;">
}</div>
<div style="margin-bottom: 0cm;">
}</div>
<div style="margin-bottom: 0cm;">
<br /></div>
<div style="margin-bottom: 0cm;">
<br /></div>
<div style="margin-bottom: 0cm;">
return jugada_ganadora; <span style="color: #38761d;">//sólo llega
a esta línea de código cuando no es jugada ganadora</span></div>
<div style="margin-bottom: 0cm;">
}</div>
<div style="margin-bottom: 0cm;">
<br /></div>
<div style="margin-bottom: 0cm;">
<br /></div>
<div style="margin-bottom: 0cm;">
<br /></div>
<div style="margin-bottom: 0cm;">
Incorporamos la llamada a la función
en el programa principal</div>
<div style="margin-bottom: 0cm;">
var boolean fin_juego = false;</div>
<div style="margin-bottom: 0cm;">
var int turno = 0; <span style="color: #38761d;">//los jugadores son
0 y 1</span></div>
<div style="margin-bottom: 0cm;">
var int casillas_vacias = 9;</div>
<div style="margin-bottom: 0cm;">
var char tablero [3][3];<span style="color: #38761d;">//matriz de 3 x
3 que representa al tablero</span></div>
<div style="margin-bottom: 0cm;">
var int fila_jugada;</div>
<div style="margin-bottom: 0cm;">
var int columna_jugada;</div>
<div style="margin-bottom: 0cm;">
var char ficha='0'; <span style="color: #38761d;">//será 'X' cuando
el turno sea 1</span></div>
<div style="margin-bottom: 0cm;">
<br /></div>
<div style="margin-bottom: 0cm;">
while(<b>!</b>fin_juego)</div>
<div style="margin-bottom: 0cm;">
{</div>
<div style="margin-bottom: 0cm;">
<span style="color: #38761d;"> //se hace la jugada</span></div>
<div style="margin-bottom: 0cm;">
fila_jugada = leer(); <span style="color: #38761d;">//lee de
consola la fila (de 0 a 2) que selecciona el jugador en ese turno</span></div>
<div style="margin-bottom: 0cm;">
columna_jugada = leer(); <span style="color: #38761d;">//lee de
consola la columna (de 0 a 2) que selecciona el jugador en ese turno</span></div>
<div style="margin-bottom: 0cm;">
if(turno == 0) ficha = '0'; <span style="color: #38761d;">//escoge
ficha</span></div>
<div style="margin-bottom: 0cm;">
else ficha = 'X';</div>
<div style="margin-bottom: 0cm;">
tablero[fila_jugada][columna_jugada]
= ficha;</div>
<div style="margin-bottom: 0cm;">
casillas_vacias = casillas_vacias -
1; <span style="color: #38761d;">//al hacer la jugada disminuye en 1 las casillas vacías</span></div>
<div style="margin-bottom: 0cm;">
<br /></div>
<div style="margin-bottom: 0cm;">
<span style="color: #38761d;"><b> //si se gana en este turno fin_juego
= true;</b></span></div>
<div style="margin-bottom: 0cm;">
<b> fin_juego = esGanador(tablero,
fila_jugada, columna_jugada);</b></div>
<div style="margin-bottom: 0cm;">
<br /></div>
<div style="margin-bottom: 0cm;">
<span style="color: #38761d;"> //si el tablero se llena sin ganador
fin_juego = true;</span></div>
<div style="margin-bottom: 0cm;">
if(<b>!</b>fin_juego &&
casillas_vacias == 0) fin_juego = true;</div>
<div style="margin-bottom: 0cm;">
</div>
<div style="margin-bottom: 0cm;">
turno = (turno + 1) % 2; <span style="color: #38761d;">//esto es
para cambiar el turno de 0 a 1 y de 1 a 0</span></div>
<div style="margin-bottom: 0cm;">
}</div>
<div style="margin-bottom: 0cm;">
<br /></div>
<div style="margin-bottom: 0cm;">
<br /></div>
<div style="margin-bottom: 0cm;">
Con esto tendríamos lo básico para el
tres en raya, pero ¿qué pasaría si el jugador pusiera la ficha en
un lugar ocupado? ¿qué pasaría si inicialmente el tablero está
ocupado?¿No vendría bien agregar una impresión del tablero para
que jugador sepa en cada jugada cuáles son sus opciones de juego?</div>
<div style="margin-bottom: 0cm;">
<br /></div>
<div style="margin-bottom: 0cm;">
¿Cómo modificaríais el programa para
agregar estas funcionalidades?</div>
<div style="margin-bottom: 0cm;">
<br /></div>
<div style="margin-bottom: 0cm;">
<h3>
<b>Enlaces</b></h3>
</div>
<div style="margin-bottom: 0cm;">
<a href="https://es.wikipedia.org/wiki/Tres_en_l%C3%ADnea" target="_blank">Tres en raya (wikipedia)</a></div>
<div style="margin-bottom: 0cm;">
<br /></div>
<br />
<div style="margin-bottom: 0cm;">
<br /></div>
MIPBhttp://www.blogger.com/profile/15144077089562468638noreply@blogger.com0tag:blogger.com,1999:blog-8606551171960007078.post-63990608865235071402015-03-08T04:58:00.001-07:002015-03-08T05:00:50.222-07:00Instancia de un objeto<div style="text-align: justify;">
A veces nos resulta complicado controlar que todos los atributos de todas las clases queden bien instanciados, para tener todo esto mejor controlado lo mejor es tener un diagrama de clases para saber qué clases deben instanciar a qué otras.</div>
<div>
<div style="text-align: justify;">
<br /></div>
<div>
<div style="text-align: justify;">
A continuación os mostraré lo que puede ocurrir si no tenemos bien controladas todas las instancias.</div>
<div style="text-align: justify;">
<br /></div>
</div>
<div>
<div style="text-align: justify;">
Tenemos una clase llamada Persona:</div>
</div>
<div>
<span style="font-size: x-small;"><span style="font-family: Courier New, Courier, monospace;"><br /></span></span>
<span style="font-family: Courier New, Courier, monospace;">using System.IO;</span><br />
<span style="font-family: Courier New, Courier, monospace;">using System;</span><br />
<span style="font-family: Courier New, Courier, monospace;">public class Persona</span><span style="font-family: Courier New, Courier, monospace;">{</span><span style="font-family: Courier New, Courier, monospace;"> </span><br />
<span style="font-family: Courier New, Courier, monospace;"><br /></span>
<span style="font-family: Courier New, Courier, monospace;"> string nombre;</span><span style="font-family: Courier New, Courier, monospace;"> </span><br />
<span style="font-family: Courier New, Courier, monospace;"> int edad;</span><span style="font-family: Courier New, Courier, monospace;"> </span><br />
<span style="font-family: Courier New, Courier, monospace;"> char sexo;</span><span style="font-family: Courier New, Courier, monospace;"> </span><span style="font-family: Courier New, Courier, monospace;"> </span><br />
<span style="font-family: Courier New, Courier, monospace;"> public Persona()</span><span style="font-family: Courier New, Courier, monospace;"> </span><br />
<span style="font-family: Courier New, Courier, monospace;"> {</span><span style="font-family: Courier New, Courier, monospace;"> nombre = "";</span><span style="font-family: Courier New, Courier, monospace;"> </span><br />
<span style="font-family: Courier New, Courier, monospace;"> edad = 0;</span><span style="font-family: Courier New, Courier, monospace;"> </span><br />
<span style="font-family: Courier New, Courier, monospace;"> sexo = ' ';</span><span style="font-family: Courier New, Courier, monospace;"> </span><br />
<span style="font-family: Courier New, Courier, monospace;"> }</span><span style="font-family: Courier New, Courier, monospace;"> </span><br />
<span style="font-family: Courier New, Courier, monospace;"> public Persona(string pNombre, int pEdad, char pSexo)</span><span style="font-family: Courier New, Courier, monospace;"> </span><br />
<span style="font-family: Courier New, Courier, monospace;"> {</span><span style="font-family: Courier New, Courier, monospace;"> nombre = pNombre;</span><br />
<span style="font-family: Courier New, Courier, monospace;"> edad = pEdad;</span><br />
<span style="font-family: Courier New, Courier, monospace;"> sexo = pSexo;</span><span style="font-family: Courier New, Courier, monospace;"> </span><br />
<span style="font-family: Courier New, Courier, monospace;"> }</span><span style="font-family: Courier New, Courier, monospace;"> </span><span style="font-family: Courier New, Courier, monospace;"> </span><br />
<span style="font-family: Courier New, Courier, monospace;"> public void imprimir()</span><span style="font-family: Courier New, Courier, monospace;"> </span><br />
<span style="font-family: Courier New, Courier, monospace;"> {</span><span style="font-family: Courier New, Courier, monospace;"> Console.WriteLine("Persona-Nombre: "+nombre);</span><br />
<span style="font-family: Courier New, Courier, monospace;"> </span><span style="font-family: Courier New, Courier, monospace;">Console.WriteLine("</span><span style="font-family: 'Courier New', Courier, monospace;">Persona-</span><span style="font-family: 'Courier New', Courier, monospace;">Edad: "+edad);</span><br />
<span style="font-family: Courier New, Courier, monospace;"> Console.WriteLine("</span><span style="font-family: 'Courier New', Courier, monospace;">Persona-</span><span style="font-family: 'Courier New', Courier, monospace;">Sexo: "+ sexo);</span><br />
<span style="font-family: Courier New, Courier, monospace;"> }</span><br />
<span style="font-family: Courier New, Courier, monospace;">}</span></div>
<div>
<br /></div>
<div>
Y tenemos una clase llamada Cliente que incluye a un objeto de tipo Persona, en este caso <u>es Cliente el que debe instanciar al objeto de tipo Persona</u><br />
<u><br /></u></div>
<div>
<div>
<span style="font-family: Courier New, Courier, monospace;">using System.IO;</span></div>
<div>
<span style="font-family: Courier New, Courier, monospace;">using System;</span></div>
<div>
<span style="font-family: Courier New, Courier, monospace;">public class Cliente</span></div>
<div>
<span style="font-family: Courier New, Courier, monospace;">{</span></div>
<div>
<span style="font-family: Courier New, Courier, monospace;"> int codigo;</span></div>
<div>
<span style="font-family: Courier New, Courier, monospace;"> Persona persona;</span></div>
<div>
<span style="font-family: Courier New, Courier, monospace;"> </span></div>
<div>
<span style="font-family: Courier New, Courier, monospace;"> public Cliente()</span></div>
<div>
<span style="font-family: Courier New, Courier, monospace;"> {</span></div>
<div>
<span style="font-family: Courier New, Courier, monospace;"> codigo = 0;</span></div>
<div>
<span style="font-family: Courier New, Courier, monospace;"> persona = new Persona();<span style="color: #274e13;"><b>//es en el constructor del cliente que instanciamos al objeto de tipo Persona</b></span></span></div>
<div>
<span style="font-family: Courier New, Courier, monospace;"> }</span></div>
<div>
<span style="font-family: Courier New, Courier, monospace;"> public void imprimir()</span></div>
<div>
<span style="font-family: Courier New, Courier, monospace;"> {</span></div>
<div>
<span style="font-family: Courier New, Courier, monospace;"> Console.WriteLine("Cliente-Codigo: "+codigo);</span></div>
<div>
<span style="font-family: Courier New, Courier, monospace;"> persona.imprimir();</span></div>
<div>
<span style="font-family: Courier New, Courier, monospace;"> }</span></div>
<div>
<span style="font-family: Courier New, Courier, monospace;">}</span></div>
</div>
<div>
<br /></div>
<div>
Si ejecutamos este código:<br />
<br /></div>
<div>
<div>
<span style="font-family: Courier New, Courier, monospace;">using System.IO;</span></div>
<div>
<span style="font-family: Courier New, Courier, monospace;">using System;</span></div>
<div>
<span style="font-family: Courier New, Courier, monospace;"><br /></span></div>
<div>
<span style="font-family: Courier New, Courier, monospace;">class Program</span></div>
<div>
<span style="font-family: Courier New, Courier, monospace;">{</span></div>
<div>
<span style="font-family: Courier New, Courier, monospace;"> static void Main()</span></div>
<div>
<span style="font-family: Courier New, Courier, monospace;"> {</span></div>
<div>
<span style="font-family: Courier New, Courier, monospace;"> Cliente cliente = new Cliente();</span></div>
<div>
<span style="font-family: Courier New, Courier, monospace;"> cliente.imprimir();</span></div>
<div>
<span style="font-family: Courier New, Courier, monospace;"> }</span></div>
<div>
<span style="font-family: Courier New, Courier, monospace;">}</span></div>
</div>
<div>
<br /></div>
<div>
El resultado de la ejecución es la siguiente:</div>
<div>
<div>
<div style="background-color: #285627; color: #f0f0f0; font-family: 'DejaVu Sans Mono', 'Liberation Mono', monospace; font-size: 14px; white-space: nowrap;">
Cliente-Codigo: 0 </div>
<div style="background-color: #285627; color: #f0f0f0; font-family: 'DejaVu Sans Mono', 'Liberation Mono', monospace; font-size: 14px; white-space: nowrap;">
Persona-Nombre: </div>
<div style="background-color: #285627; color: #f0f0f0; font-family: 'DejaVu Sans Mono', 'Liberation Mono', monospace; font-size: 14px; white-space: nowrap;">
Persona-Edad: 0 </div>
<div style="background-color: #285627; color: #f0f0f0; font-family: 'DejaVu Sans Mono', 'Liberation Mono', monospace; font-size: 14px; white-space: nowrap;">
Persona-Sexo: </div>
</div>
</div>
<div>
<br /></div>
<div>
Ahora os mostraré lo que pasaría en el caso que en el constructor de cliente NO se instancie el objeto persona, comentaremos la linea<br />
<br /></div>
</div>
<div>
<div>
<span style="font-family: Courier New, Courier, monospace;">public Cliente()</span></div>
<div>
<span style="font-family: Courier New, Courier, monospace;"> {</span></div>
<div>
<span style="font-family: Courier New, Courier, monospace;"> codigo = 0;</span></div>
<div>
<span style="font-family: Courier New, Courier, monospace;"> <span style="color: #274e13;"><b><span style="background-color: #d9ead3;">//persona = new Persona();</span>//es en el constructor del cliente que instanciamos al objeto de tipo Persona</b></span></span></div>
<div>
<span style="font-family: Courier New, Courier, monospace;"> }</span></div>
</div>
<div>
<br /></div>
<div>
El compilador no nos avisará, porque no es un error sintáctico, pero el error vendrá en la ejecución:</div>
<div>
<div style="background-color: #285627; color: #f0f0f0; font-family: 'DejaVu Sans Mono', 'Liberation Mono', monospace; font-size: 14px; white-space: nowrap;">
Cliente-Codigo: 0 </div>
<div style="background-color: #285627; color: #f0f0f0; font-family: 'DejaVu Sans Mono', 'Liberation Mono', monospace; font-size: 14px; white-space: nowrap;">
</div>
<div style="background-color: #285627; color: #f0f0f0; font-family: 'DejaVu Sans Mono', 'Liberation Mono', monospace; font-size: 14px; white-space: nowrap;">
Unhandled Exception: </div>
<div style="background-color: #285627; color: #f0f0f0; font-family: 'DejaVu Sans Mono', 'Liberation Mono', monospace; font-size: 14px; white-space: nowrap;">
System.NullReferenceException: Object reference not set to an instance of an object </div>
<div style="background-color: #285627; color: #f0f0f0; font-family: 'DejaVu Sans Mono', 'Liberation Mono', monospace; font-size: 14px; white-space: nowrap;">
at Cliente.imprimir () [0x00000] in <filename unknown>:0 </div>
<div style="background-color: #285627; color: #f0f0f0; font-family: 'DejaVu Sans Mono', 'Liberation Mono', monospace; font-size: 14px; white-space: nowrap;">
at Program.Main () [0x00000] in <filename unknown>:0 </div>
<div style="background-color: #285627; color: #f0f0f0; font-family: 'DejaVu Sans Mono', 'Liberation Mono', monospace; font-size: 14px; white-space: nowrap;">
[ERROR] FATAL UNHANDLED EXCEPTION: System.NullReferenceException: Object reference not set to an instance of an object </div>
<div style="background-color: #285627; color: #f0f0f0; font-family: 'DejaVu Sans Mono', 'Liberation Mono', monospace; font-size: 14px; white-space: nowrap;">
at Cliente.imprimir () [0x00000] in <filename unknown>:0 </div>
<div style="background-color: #285627; color: #f0f0f0; font-family: 'DejaVu Sans Mono', 'Liberation Mono', monospace; font-size: 14px; white-space: nowrap;">
at Program.Main () [0x00000] in <filename unknown>:0 </div>
</div>
<div>
<br /></div>
<div>
Vemos que Cliente-codigo si que lo ha impreso correctamente, pero a partir de allí la impresión del objeto persona dio error por NULLReference, esto es porque no está instanciado el objeto.</div>
<div>
<br /></div>
<div>
Ahora que hemos visto la importancia de tener controladas las instancias os mostraré como instanciar con valores al objeto persona a partir de la clase Cliente.</div>
<div>
<br /></div>
<div>
Vimos que la clase Persona tiene el constructor:</div>
<div>
<div>
<span style="font-family: Courier New, Courier, monospace;"> public Persona(string pNombre, int pEdad, char pSexo)</span></div>
<div>
<span style="font-family: Courier New, Courier, monospace;"> {</span></div>
<div>
<span style="font-family: Courier New, Courier, monospace;"> nombre = pNombre;</span></div>
<div>
<span style="font-family: Courier New, Courier, monospace;"> edad = pEdad;</span></div>
<div>
<span style="font-family: Courier New, Courier, monospace;"> sexo = pSexo;</span></div>
<div>
<span style="font-family: Courier New, Courier, monospace;"> }</span></div>
</div>
<div>
<br /></div>
<div>
Agregamos ahora un nuevo constructor a la clase Cliente que utilice este constructor de la clase Persona:</div>
<div>
<div>
<span style="font-family: Courier New, Courier, monospace;"> public Cliente(int pCodigo, string pNombre, int pEdad, char pSexo)</span></div>
<div>
<span style="font-family: Courier New, Courier, monospace;"> {</span></div>
<div>
<span style="font-family: Courier New, Courier, monospace;"> codigo = pCodigo;</span></div>
<div>
<span style="font-family: Courier New, Courier, monospace;"> persona = new Persona(pNombre, pEdad, pSexo);</span></div>
<div>
<span style="font-family: Courier New, Courier, monospace;"> }</span></div>
</div>
<div>
<br /></div>
<div>
Y desde el Main le pasamos todos los valores utilizando este nuevo constructor de la clase Cliente:</div>
<div>
<div>
<span style="font-family: Courier New, Courier, monospace;"> static void Main()</span></div>
<div>
<span style="font-family: Courier New, Courier, monospace;"> {</span></div>
<div>
<span style="font-family: Courier New, Courier, monospace;"> Cliente cliente = new Cliente(1, "Juan", 30, 'H');</span></div>
<div>
<span style="font-family: Courier New, Courier, monospace;"> cliente.imprimir();</span></div>
<div>
<span style="font-family: Courier New, Courier, monospace;"> }</span></div>
</div>
<div>
<br /></div>
<div>
Y finalmente vemos la ejecución:</div>
<div>
<div style="background-color: #285627; color: #f0f0f0; font-family: 'DejaVu Sans Mono', 'Liberation Mono', monospace; font-size: 14px; white-space: nowrap;">
Cliente-Codigo: 1 </div>
<div style="background-color: #285627; color: #f0f0f0; font-family: 'DejaVu Sans Mono', 'Liberation Mono', monospace; font-size: 14px; white-space: nowrap;">
Persona-Nombre: Juan </div>
<div style="background-color: #285627; color: #f0f0f0; font-family: 'DejaVu Sans Mono', 'Liberation Mono', monospace; font-size: 14px; white-space: nowrap;">
Persona-Edad: 30 </div>
<div style="background-color: #285627; color: #f0f0f0; font-family: 'DejaVu Sans Mono', 'Liberation Mono', monospace; font-size: 14px; white-space: nowrap;">
Persona-Sexo: H </div>
</div>
<div>
<br /></div>
<div>
<br /></div>
<div>
<br /></div>
<div>
<br /></div>
<div>
<br /></div>
MIPBhttp://www.blogger.com/profile/15144077089562468638noreply@blogger.com0tag:blogger.com,1999:blog-8606551171960007078.post-629556595833814022014-11-23T03:20:00.001-08:002014-11-23T03:20:56.066-08:00Push en una PilaCuando nos explican el concepto de Pilas lo principal es que: "el primero que entra es el primero que sale":<br />
<br />
<div class="separator" style="clear: both; text-align: center;">
<a href="https://blogger.googleusercontent.com/img/b/R29vZ2xl/AVvXsEg-EHK3r920TJszeFnN03zykS0JbtxDost0Lk7uEKBsfdsLw_TlqnhRzzHhxUSbLfpesl-gesUy7Mv7-uylvWE7d62O4wLJAVqmvZVtDqgVPrOOsMrWtW_ypyh78VpGFOSVAcBtcQ_KbBo/s1600/pila_push_pop.jpg" imageanchor="1" style="margin-left: 1em; margin-right: 1em;"><img border="0" src="https://blogger.googleusercontent.com/img/b/R29vZ2xl/AVvXsEg-EHK3r920TJszeFnN03zykS0JbtxDost0Lk7uEKBsfdsLw_TlqnhRzzHhxUSbLfpesl-gesUy7Mv7-uylvWE7d62O4wLJAVqmvZVtDqgVPrOOsMrWtW_ypyh78VpGFOSVAcBtcQ_KbBo/s1600/pila_push_pop.jpg" height="175" width="320" /></a></div>
<br />
con esto parece que tenemos toda la teoría aprendida, el problema viene cuando intentamos implementarlo y no sabemos por dónde empezar.<br />
<br />
Por lo general cuando se explica este tema se hace en C++ y utilizando estructuras, por tanto antes de continuar esta explicación os recomiendo leer previamente el post relacionado a <a href="http://ejemplosalgoritmos.blogspot.com.es/2013/10/estructuras-struct.html" target="_blank">estructuras</a><br />
<br />
Vemos en la imagen que cada elemento de la pila está formado por un círculo con un valor y una flecha que lo une con el siguiente círculo, con estos dos elementos formaremos un elemento de la Pila, de esta forma:<br />
<br />
<span style="font-family: Courier New, Courier, monospace; font-size: x-small;">struct ElemPila{</span><br />
<span style="font-family: Courier New, Courier, monospace; font-size: x-small;"> int valor; <span style="color: #38761d;">//esto representa el valor que está dentro del círculo</span></span><br />
<span style="font-family: Courier New, Courier, monospace; font-size: x-small;"> struct ElemPila * siguienteElem; <span style="color: #38761d;">//esto representa la flecha, observar que es un puntero</span></span><br />
<span style="font-family: Courier New, Courier, monospace; font-size: x-small;">};</span><br />
<br />
Hasta aquí tenemos definida la estructura, pero aún no la estamos utilizando, ahora veremos como desde el programa utilizamos esta esta estructura para agregar los elementos: 1, 2 y 3:<br />
<br />
<span style="font-family: Courier New, Courier, monospace; font-size: x-small;">int main()</span><br />
<span style="font-family: Courier New, Courier, monospace; font-size: x-small;">{</span><br />
<span style="color: #38761d; font-family: Courier New, Courier, monospace; font-size: x-small;"> / /Creamos el primer elemento, con valor 1 y la flecha que apunta al siguiente elemento apunta a NULL</span><br />
<span style="font-family: Courier New, Courier, monospace; font-size: x-small;"> struct ElemPila* elem1 = new ElemPila; <span style="color: #38761d;">//reserva memoria para el contenido de la estructura</span></span><br />
<span style="font-family: Courier New, Courier, monospace; font-size: x-small;"> elem1->valor = 1; <span style="color: #38761d;">//inicializa el valor de la estructura</span></span><br />
<span style="font-family: Courier New, Courier, monospace; font-size: x-small;"> elem1->siguienteElem = NULL; <span style="color: #38761d;">//inicializa el valor hacia donde apunta el siguiente</span></span><br />
<span style="font-family: Courier New, Courier, monospace; font-size: x-small;"> </span><br />
<span style="font-family: Courier New, Courier, monospace; font-size: x-small;"> struct ElemPila* elem2 = new ElemPila;</span><br />
<span style="font-family: Courier New, Courier, monospace; font-size: x-small;"> elem2->valor = 2;</span><br />
<span style="font-family: Courier New, Courier, monospace; font-size: x-small;"> elem2->siguienteElem = NULL;</span><br />
<span style="font-family: Courier New, Courier, monospace; font-size: x-small;"> </span><br />
<span style="font-family: Courier New, Courier, monospace; font-size: x-small;"> struct ElemPila* elem3 = new ElemPila;</span><br />
<span style="font-family: Courier New, Courier, monospace; font-size: x-small;"> elem3->valor = 3;</span><br />
<span style="font-family: Courier New, Courier, monospace; font-size: x-small;"> elem3->siguienteElem = NULL;</span><br />
<span style="font-family: Courier New, Courier, monospace; font-size: x-small;"> </span><br />
<span style="font-family: Courier New, Courier, monospace; font-size: x-small;"> return 0;</span><br />
<span style="font-family: Courier New, Courier, monospace; font-size: x-small;">}</span><br />
<br />
Al ejecutar este programa lo que logramos es tener 3 elementos independientes, así:<br />
<br />
<div class="separator" style="clear: both; text-align: center;">
<a href="https://blogger.googleusercontent.com/img/b/R29vZ2xl/AVvXsEiSKTtbxqp0Uwi3rVRYfVPUYF6xClj0Peh4qekDwTFZpDpkWH_C__LHZlWtnlvW_77cV6R7RPCpupDPgdI6pUX9AxrGLOzlcotnuVgJng0m0kfdqjv8HGaDutwI1LkA-iQYi1OqDf5W2g8/s1600/elementospila.jpg" imageanchor="1" style="margin-left: 1em; margin-right: 1em;"><img border="0" src="https://blogger.googleusercontent.com/img/b/R29vZ2xl/AVvXsEiSKTtbxqp0Uwi3rVRYfVPUYF6xClj0Peh4qekDwTFZpDpkWH_C__LHZlWtnlvW_77cV6R7RPCpupDPgdI6pUX9AxrGLOzlcotnuVgJng0m0kfdqjv8HGaDutwI1LkA-iQYi1OqDf5W2g8/s1600/elementospila.jpg" /></a></div>
<br />
Como paso siguiente modificaremos el programa para introducir el puntero que será cabeza de la pila e introduciremos sólo el primer elemento a la pila:<br />
<span style="font-family: Courier New, Courier, monospace; font-size: x-small;"><br /></span>
<span style="font-family: Courier New, Courier, monospace; font-size: x-small;">int main()</span><br />
<span style="font-family: Courier New, Courier, monospace; font-size: x-small;">{</span><br />
<span style="font-family: Courier New, Courier, monospace; font-size: x-small;"> struct ElemPila* elem1 = new ElemPila;</span><br />
<span style="font-family: Courier New, Courier, monospace; font-size: x-small;"> elem1->valor = 1;</span><br />
<span style="font-family: Courier New, Courier, monospace; font-size: x-small;"> elem1->siguienteElem = NULL;</span><br />
<span style="font-family: Courier New, Courier, monospace; font-size: x-small;"> </span><br />
<span style="font-family: Courier New, Courier, monospace; font-size: x-small;"> struct ElemPila* elem2 = new ElemPila;</span><br />
<span style="font-family: Courier New, Courier, monospace; font-size: x-small;"> elem2->valor = 2;</span><br />
<span style="font-family: Courier New, Courier, monospace; font-size: x-small;"> elem2->siguienteElem = NULL;</span><br />
<span style="font-family: Courier New, Courier, monospace; font-size: x-small;"> </span><br />
<span style="font-family: Courier New, Courier, monospace; font-size: x-small;"> struct ElemPila* elem3 = new ElemPila;</span><br />
<span style="font-family: Courier New, Courier, monospace; font-size: x-small;"> elem3->valor = 3;</span><br />
<span style="font-family: Courier New, Courier, monospace; font-size: x-small;"> elem3->siguienteElem = NULL;</span><br />
<span style="font-family: Courier New, Courier, monospace; font-size: x-small;"> </span><br />
<span style="font-family: Courier New, Courier, monospace;"><span style="font-size: x-small;"> </span><b>struct ElemPila* cabezaPila; </b><span style="color: #38761d; font-size: x-small;">//creamos el puntero</span></span><br />
<span style="font-family: Courier New, Courier, monospace;"><span style="font-size: x-small;"> </span><b>cabezaPila = elem1;</b> <span style="color: #38761d; font-size: x-small;">//hacemos que apunte al primer elemento</span></span><br />
<span style="font-family: Courier New, Courier, monospace; font-size: x-small;"> </span><br />
<span style="font-family: Courier New, Courier, monospace; font-size: x-small;"> return 0;</span><br />
<span style="font-family: Courier New, Courier, monospace; font-size: x-small;">}</span><br />
<div>
<br /></div>
<div class="separator" style="clear: both; text-align: center;">
<a href="https://blogger.googleusercontent.com/img/b/R29vZ2xl/AVvXsEjt_OQ34roW_qLtltB53n40a8r57ru6n38S879z58vJeAeDqd7-5DPXzqTPr-x0MhvYBBsoB3gZrnMdNFWUv0iHcaUUcyY1uLpVyeqlGod1D0Av3H6C8K6ESGIWkugvyE_HmeFr4YkqsOk/s1600/elementospila-elem1.jpg" imageanchor="1" style="margin-left: 1em; margin-right: 1em;"><img border="0" src="https://blogger.googleusercontent.com/img/b/R29vZ2xl/AVvXsEjt_OQ34roW_qLtltB53n40a8r57ru6n38S879z58vJeAeDqd7-5DPXzqTPr-x0MhvYBBsoB3gZrnMdNFWUv0iHcaUUcyY1uLpVyeqlGod1D0Av3H6C8K6ESGIWkugvyE_HmeFr4YkqsOk/s1600/elementospila-elem1.jpg" /></a></div>
<div>
<br /></div>
<div>
<br /></div>
<div>
Para incluir el segundo elemento en la pila, lo que tenemos que hacer es que el segundo elemento apunte al primero (elem1) y la cabeza de pila apunte al segundo:</div>
<div>
<br /></div>
<div>
<div>
<span style="font-family: Courier New, Courier, monospace; font-size: x-small;">int main()</span></div>
<div>
<span style="font-family: Courier New, Courier, monospace; font-size: x-small;">{</span></div>
<div>
<span style="font-family: Courier New, Courier, monospace; font-size: x-small;"> struct ElemPila* elem1 = new ElemPila;</span></div>
<div>
<span style="font-family: Courier New, Courier, monospace; font-size: x-small;"> elem1->valor = 1;</span></div>
<div>
<span style="font-family: Courier New, Courier, monospace; font-size: x-small;"> elem1->siguienteElem = NULL;</span></div>
<div>
<span style="font-family: Courier New, Courier, monospace; font-size: x-small;"><br /></span></div>
<div>
<span style="font-family: Courier New, Courier, monospace; font-size: x-small;"> struct ElemPila* elem2 = new ElemPila;</span></div>
<div>
<span style="font-family: Courier New, Courier, monospace; font-size: x-small;"> elem2->valor = 2;</span></div>
<div>
<span style="font-family: Courier New, Courier, monospace; font-size: x-small;"> elem2->siguienteElem = NULL;</span></div>
<div>
<span style="font-family: Courier New, Courier, monospace; font-size: x-small;"><br /></span></div>
<div>
<span style="font-family: Courier New, Courier, monospace; font-size: x-small;"> struct ElemPila* elem3 = new ElemPila;</span></div>
<div>
<span style="font-family: Courier New, Courier, monospace; font-size: x-small;"> elem3->valor = 3;</span></div>
<div>
<span style="font-family: Courier New, Courier, monospace; font-size: x-small;"> elem3->siguienteElem = NULL;</span></div>
<div>
<span style="font-family: Courier New, Courier, monospace; font-size: x-small;"><br /></span></div>
<div>
<span style="font-family: Courier New, Courier, monospace; font-size: x-small;"> struct ElemPila* cabezaPila;</span></div>
<div>
<span style="font-family: Courier New, Courier, monospace; font-size: x-small;"> cabezaPila = elem1;</span></div>
<div>
<span style="font-family: Courier New, Courier, monospace; font-size: x-small;"><br /></span></div>
<div>
<span style="font-family: Courier New, Courier, monospace;"><b> elem2-> siguienteElem = cabezaPila;</b></span></div>
<div>
<span style="font-family: Courier New, Courier, monospace;"><b> cabezaPila = elem2;</b></span></div>
<div>
<span style="font-family: Courier New, Courier, monospace; font-size: x-small;"><br /></span></div>
<div>
<span style="font-family: Courier New, Courier, monospace; font-size: x-small;"> return 0;</span></div>
<div>
<span style="font-family: Courier New, Courier, monospace; font-size: x-small;">}</span></div>
</div>
<div>
<br /></div>
<div class="separator" style="clear: both; text-align: center;">
<a href="https://blogger.googleusercontent.com/img/b/R29vZ2xl/AVvXsEh2apmLxo5Dr1yFdBdvDckuivxdF1mHdvaoky2GXlNMo4V2Be5tfy3fihpiPjfyEijyX-QE8dvs-Q5aILPBhqr2JkJg3KuqMOwPMXauEQNbdbvw7w7POxKtJhL0XQzEWIhvsIFfiHLK_zQ/s1600/elementospila-elem2.jpg" imageanchor="1" style="margin-left: 1em; margin-right: 1em;"><img border="0" src="https://blogger.googleusercontent.com/img/b/R29vZ2xl/AVvXsEh2apmLxo5Dr1yFdBdvDckuivxdF1mHdvaoky2GXlNMo4V2Be5tfy3fihpiPjfyEijyX-QE8dvs-Q5aILPBhqr2JkJg3KuqMOwPMXauEQNbdbvw7w7POxKtJhL0XQzEWIhvsIFfiHLK_zQ/s1600/elementospila-elem2.jpg" /></a></div>
<div>
<br /></div>
<div>
Finalmente incluimos el tercer elemento, siguiendo los mismo pasos que el anterior, que es hacer que el siguiente de elemento 3 apunte al elemento 2 y la cabeza de la pila apunte a elemento 3:</div>
<div>
<br /></div>
<div>
<div>
<span style="font-family: Courier New, Courier, monospace; font-size: x-small;">int main()</span></div>
<div>
<span style="font-family: Courier New, Courier, monospace; font-size: x-small;">{</span></div>
<div>
<span style="font-family: Courier New, Courier, monospace; font-size: x-small;"> struct ElemPila* elem1 = new ElemPila;</span></div>
<div>
<span style="font-family: Courier New, Courier, monospace; font-size: x-small;"> elem1->valor = 1;</span></div>
<div>
<span style="font-family: Courier New, Courier, monospace; font-size: x-small;"> elem1->siguienteElem = NULL;</span></div>
<div>
<span style="font-family: Courier New, Courier, monospace; font-size: x-small;"> </span></div>
<div>
<span style="font-family: Courier New, Courier, monospace; font-size: x-small;"> struct ElemPila* elem2 = new ElemPila;</span></div>
<div>
<span style="font-family: Courier New, Courier, monospace; font-size: x-small;"> elem2->valor = 2;</span></div>
<div>
<span style="font-family: Courier New, Courier, monospace; font-size: x-small;"> elem2->siguienteElem = NULL;</span></div>
<div>
<span style="font-family: Courier New, Courier, monospace; font-size: x-small;"> </span></div>
<div>
<span style="font-family: Courier New, Courier, monospace; font-size: x-small;"> struct ElemPila* elem3 = new ElemPila;</span></div>
<div>
<span style="font-family: Courier New, Courier, monospace; font-size: x-small;"> elem3->valor = 3;</span></div>
<div>
<span style="font-family: Courier New, Courier, monospace; font-size: x-small;"> elem3->siguienteElem = NULL;</span></div>
<div>
<span style="font-family: Courier New, Courier, monospace; font-size: x-small;"> </span></div>
<div>
<span style="font-family: Courier New, Courier, monospace; font-size: x-small;"> struct ElemPila* cabezaPila;</span></div>
<div>
<span style="font-family: Courier New, Courier, monospace; font-size: x-small;"> cabezaPila = elem1;</span></div>
<div>
<span style="font-family: Courier New, Courier, monospace; font-size: x-small;"> </span></div>
<div>
<span style="font-family: Courier New, Courier, monospace; font-size: x-small;"> elem2->siguienteElem = cabezaPila;</span></div>
<div>
<span style="font-family: Courier New, Courier, monospace; font-size: x-small;"> cabezaPila = elem2;</span></div>
<div>
<span style="font-family: Courier New, Courier, monospace; font-size: x-small;"> </span></div>
<div>
<span style="font-family: Courier New, Courier, monospace;"><b> elem3->siguienteElem = cabezaPila;</b></span></div>
<div>
<span style="font-family: Courier New, Courier, monospace;"><b> cabezaPila = elem3;</b></span></div>
<div>
<span style="font-family: Courier New, Courier, monospace; font-size: x-small;"> </span></div>
<div>
<span style="font-family: Courier New, Courier, monospace; font-size: x-small;"> return 0;</span></div>
<div>
<span style="font-family: Courier New, Courier, monospace; font-size: x-small;">}</span></div>
</div>
<div>
<br /></div>
<div class="separator" style="clear: both; text-align: center;">
<a href="https://blogger.googleusercontent.com/img/b/R29vZ2xl/AVvXsEglgeA9Xtjn0bGhIYs1YLCwjBnPQV3i5zTK6noBgmpO8sxU8RitH8pBkTrG0W48EyKcZITcHUl6yCL3uh2xTaMsjg8VfU143pYL7tiTbX50mrhVvqQhAKUTfpkh3owXD0wLfTWy7yIZcu8/s1600/elementospila-elem3.jpg" imageanchor="1" style="margin-left: 1em; margin-right: 1em;"><img border="0" src="https://blogger.googleusercontent.com/img/b/R29vZ2xl/AVvXsEglgeA9Xtjn0bGhIYs1YLCwjBnPQV3i5zTK6noBgmpO8sxU8RitH8pBkTrG0W48EyKcZITcHUl6yCL3uh2xTaMsjg8VfU143pYL7tiTbX50mrhVvqQhAKUTfpkh3owXD0wLfTWy7yIZcu8/s1600/elementospila-elem3.jpg" /></a></div>
<div>
<br /></div>
<div>
<br /></div>
<div>
Si observamos atentamente el código y las imágenes veremos que las variables elem1 y elem2 se quedan apuntando a elementos de la pila que en teoría no se deberían acceder directamente (el acceso es sólo con la cabeza de pila), por tanto podríamos deducir que con una sola variable de tipo ElemenPila sería suficiente. De la misma forma podemos observar en el código que el mecanismo para agregar un elemento es el mismo, por lo tanto podríamos utilizar una función para reutilizar el código. todo esto de esta forma:</div>
<div>
<br /></div>
<div>
<div>
<span style="font-family: Courier New, Courier, monospace; font-size: x-small;">#include <iostream></span></div>
<div>
<span style="font-family: Courier New, Courier, monospace; font-size: x-small;"><br /></span></div>
<div>
<span style="font-family: Courier New, Courier, monospace; font-size: x-small;">struct ElemPila{</span></div>
<div>
<span style="font-family: Courier New, Courier, monospace; font-size: x-small;"> int valor;</span></div>
<div>
<span style="font-family: Courier New, Courier, monospace; font-size: x-small;"> struct ElemPila * siguienteElem;</span></div>
<div>
<span style="font-family: Courier New, Courier, monospace; font-size: x-small;">};</span></div>
<div>
<span style="font-family: Courier New, Courier, monospace; font-size: x-small;"><br /></span></div>
<div>
<span style="font-family: Courier New, Courier, monospace; font-size: x-small;">using namespace std;</span></div>
<div>
<span style="font-family: Courier New, Courier, monospace; font-size: x-small;"><br /></span></div>
<div>
<span style="font-family: Courier New, Courier, monospace; font-size: x-small;"><br /></span></div>
<div>
<span style="color: #6aa84f; font-family: Courier New, Courier, monospace; font-size: x-small;">//incluimos una función de impresión para comprobar el orden en que se han guardado</span></div>
<div>
<span style="font-family: Courier New, Courier, monospace; font-size: x-small;">void imprimir(struct ElemPila* cabezaPila)</span></div>
<div>
<span style="font-family: Courier New, Courier, monospace; font-size: x-small;">{</span></div>
<div>
<span style="font-family: Courier New, Courier, monospace; font-size: x-small;"> struct ElemPila* auxiliar = cabezaPila;</span></div>
<div>
<span style="font-family: Courier New, Courier, monospace; font-size: x-small;"> while(auxiliar != NULL)</span></div>
<div>
<span style="font-family: Courier New, Courier, monospace; font-size: x-small;"> {</span></div>
<div>
<span style="font-family: Courier New, Courier, monospace; font-size: x-small;"> cout << auxiliar->valor << " - ";</span></div>
<div>
<span style="font-family: Courier New, Courier, monospace; font-size: x-small;"> auxiliar = auxiliar -> siguienteElem;</span></div>
<div>
<span style="font-family: Courier New, Courier, monospace; font-size: x-small;"> }</span></div>
<div>
<span style="font-family: Courier New, Courier, monospace; font-size: x-small;"> cout << "=====================\n";</span></div>
<div>
<span style="font-family: Courier New, Courier, monospace; font-size: x-small;">}</span></div>
<div>
<span style="font-family: Courier New, Courier, monospace; font-size: x-small;"><br /></span></div>
<div>
<span style="color: #38761d; font-family: Courier New, Courier, monospace; font-size: x-small;">//función que realiza el push de forma genérica para cualquier elemento</span></div>
<div>
<span style="font-family: Courier New, Courier, monospace;"><b>struct ElemPila* push(int pValor, struct ElemPila* elem, struct ElemPila* cabezaPila)</b></span></div>
<div>
<span style="font-family: Courier New, Courier, monospace;"><b>{</b></span></div>
<div>
<span style="font-family: Courier New, Courier, monospace;"><b> elem = new ElemPila; </b></span></div>
<div>
<span style="font-family: Courier New, Courier, monospace;"><b> elem->valor = pValor;</b></span></div>
<div>
<span style="font-family: Courier New, Courier, monospace;"><b> elem->siguienteElem = NULL;</b></span></div>
<div>
<span style="font-family: Courier New, Courier, monospace;"><b> elem->siguienteElem = cabezaPila;</b></span></div>
<div>
<span style="font-family: Courier New, Courier, monospace;"><b> cabezaPila = elem;</b></span></div>
<div>
<span style="font-family: Courier New, Courier, monospace;"><b> return cabezaPila;</b></span></div>
<div>
<span style="font-family: Courier New, Courier, monospace;"><b>}</b></span></div>
<div>
<span style="font-family: Courier New, Courier, monospace; font-size: x-small;"><br /></span></div>
<div>
<span style="font-family: Courier New, Courier, monospace; font-size: x-small;">int main()</span></div>
<div>
<span style="font-family: Courier New, Courier, monospace; font-size: x-small;">{</span></div>
<div>
<span style="font-family: Courier New, Courier, monospace; font-size: x-small;"> struct ElemPila* cabezaPila = NULL;</span></div>
<div>
<span style="font-family: Courier New, Courier, monospace; font-size: x-small;"> struct ElemPila* elem = NULL;</span></div>
<div>
<span style="font-family: Courier New, Courier, monospace; font-size: x-small;"><br /></span></div>
<div>
<span style="font-family: Courier New, Courier, monospace;"><b> cabezaPila = push(1, elem, cabezaPila); </b></span></div>
<div>
<span style="font-family: Courier New, Courier, monospace;"><b> imprimir(cabezaPila);</b></span></div>
<div>
<span style="font-family: Courier New, Courier, monospace;"><b> </b></span></div>
<div>
<span style="font-family: Courier New, Courier, monospace;"><b> cabezaPila = push(2, elem, cabezaPila); </b></span></div>
<div>
<span style="font-family: Courier New, Courier, monospace;"><b> imprimir(cabezaPila);</b></span></div>
<div>
<span style="font-family: Courier New, Courier, monospace;"><b> </b></span></div>
<div>
<span style="font-family: Courier New, Courier, monospace;"><b> cabezaPila = push(3, elem, cabezaPila); </b></span></div>
<div>
<span style="font-family: Courier New, Courier, monospace;"><b> imprimir(cabezaPila);</b></span></div>
<div>
<span style="font-family: Courier New, Courier, monospace; font-size: x-small;"> </span></div>
<div>
<span style="font-family: Courier New, Courier, monospace; font-size: x-small;"> return 0;</span></div>
<div>
<span style="font-family: Courier New, Courier, monospace; font-size: x-small;">}</span></div>
</div>
<div>
<span style="font-family: Courier New, Courier, monospace; font-size: x-small;"><br /></span></div>
<div>
<span style="font-family: Courier New, Courier, monospace; font-size: x-small;"><br /></span></div>
<div>
<span style="font-family: Courier New, Courier, monospace; font-size: x-small;"><b>Executing the program....</b></span><pre><span style="font-family: Courier New, Courier, monospace; font-size: x-small;">1 - =====================
2 - 1 - =====================
3 - 2 - 1 - =====================</span></pre>
</div>
MIPBhttp://www.blogger.com/profile/15144077089562468638noreply@blogger.com0tag:blogger.com,1999:blog-8606551171960007078.post-36929683426385947082014-10-21T08:49:00.001-07:002014-10-21T08:51:03.728-07:00El elemento neutro de la suma y el producto<div style="text-align: justify;">
<span style="font-family: Verdana, sans-serif;">Hay recuerdos muy lejanos al aprender a sumar o a multiplicar, en el cole (o en la universidad) nos explicaban las propiedades de la suma y del producto: propiedad transitiva, propiedad distributiva, etc. una de las propiedades (generalmente la primera) es la propiedad del elemento neutro que dice:</span></div>
<div style="text-align: justify;">
<span style="font-family: Verdana, sans-serif;"><br /></span></div>
<div style="text-align: justify;">
<span style="font-family: Verdana, sans-serif;"><i>A todo número que se le sume cero da el mismo número</i>. -> El 0 es el elemento neutro de la suma</span></div>
<div style="text-align: justify;">
<span style="font-family: Verdana, sans-serif;"><br /></span></div>
<div style="text-align: justify;">
<span style="font-family: Verdana, sans-serif;"><i>A todo número que se le multiplique por uno da el mismo número.</i> -> El 1 es el elemento neutro de la multiplicación.</span></div>
<div style="text-align: justify;">
<span style="font-family: Verdana, sans-serif;"><br /></span></div>
<div style="text-align: justify;">
<span style="font-family: Verdana, sans-serif;">¿A que viene todo esto del elemento neutro? Esto va relacionado a operaciones que hacemos de forma acumulativa, por ejemplo:</span></div>
<div style="text-align: justify;">
<span style="font-family: Verdana, sans-serif;"><br /></span></div>
<div style="text-align: justify;">
<span style="font-family: Verdana, sans-serif;">1. Calcule la suma de los N primeros números enteros.</span></div>
<div style="text-align: justify;">
<span style="font-family: Verdana, sans-serif;">2. Calcula el factorial de un número N.</span></div>
<div style="text-align: justify;">
<span style="font-family: Verdana, sans-serif;"><br /></span></div>
<div style="text-align: justify;">
<span style="font-family: Verdana, sans-serif;">En ambos casos, una de las soluciones por las que se podría optar es hacer un bucle que acumule la suma o el producto de esta forma:</span></div>
<div style="text-align: justify;">
<span style="font-family: Verdana, sans-serif;"><br /></span></div>
<div style="text-align: justify;">
<span style="color: #6aa84f; font-family: Verdana, sans-serif;">//ejemplo 1</span></div>
<div style="text-align: justify;">
<span style="font-family: Verdana, sans-serif;">Para i=1 hasta N hacer</span></div>
<div style="text-align: justify;">
<span style="font-family: Verdana, sans-serif;"> suma = suma + i;</span></div>
<div style="text-align: justify;">
<span style="font-family: Verdana, sans-serif;">Fin_Para</span></div>
<div style="text-align: justify;">
<span style="font-family: Verdana, sans-serif;"><br /></span></div>
<div style="text-align: justify;">
<span style="color: #6aa84f; font-family: Verdana, sans-serif;">//ejemplo 2</span></div>
<div style="text-align: justify;">
<span style="font-family: Verdana, sans-serif;">Para i=1 hasta N hacer</span></div>
<div style="text-align: justify;">
<span style="font-family: Verdana, sans-serif;"> factorial = factorial * i;</span></div>
<div style="text-align: justify;">
<span style="font-family: Verdana, sans-serif;">Fin_Para</span></div>
<div style="text-align: justify;">
<span style="font-family: Verdana, sans-serif;"><br /></span></div>
<div style="text-align: justify;">
<span style="font-family: Verdana, sans-serif;">En ambos casos al estar calculando un valor acumulado, reutiliza el valor de la variable en la iteración anterior (suma utiliza a suma para calcularse a si misma, lo mismo con factorial).</span></div>
<div style="text-align: justify;">
<span style="font-family: Verdana, sans-serif;">¿Pero qué pasa en la primera iteración? En la primera iteración es necesario que suma y factorial simplemente sean igual a "i", por este motivo es necesario (indispensable) inicializar ambas variables con el valor del elemento neutro. Los algoritmos completos quedarían así:</span></div>
<div style="text-align: justify;">
<span style="font-family: Verdana, sans-serif;"><br /></span></div>
<div>
<div style="text-align: justify;">
<span style="color: #6aa84f; font-family: Verdana, sans-serif;">//ejemplo 1</span></div>
<div style="text-align: justify;">
<span style="font-family: Verdana, sans-serif;">suma = 0: <span style="color: #6aa84f;">//variable inicializada con el valor del elemento neutro de la operación que haremos</span></span></div>
<div style="text-align: justify;">
<span style="font-family: Verdana, sans-serif;">Para i=1 hasta N hacer</span></div>
<div style="text-align: justify;">
<span style="font-family: Verdana, sans-serif;"> suma = suma + i <span style="color: #6aa84f;">//la primera iteración: suma = 0 + i;</span></span></div>
<div style="text-align: justify;">
<span style="font-family: Verdana, sans-serif;">Fin_Para</span></div>
<div style="text-align: justify;">
<span style="font-family: Verdana, sans-serif;"><br /></span></div>
<div style="text-align: justify;">
<span style="color: #6aa84f; font-family: Verdana, sans-serif;">//ejemplo 2</span></div>
<div style="text-align: justify;">
<span style="font-family: Verdana, sans-serif;">factorial = 1 <span style="color: #6aa84f;">//variable inicializada con el valor del elemento neutro de la operación que haremos</span></span></div>
<div style="text-align: justify;">
<span style="font-family: Verdana, sans-serif;">Para i=1 hasta N hacer</span></div>
<div style="text-align: justify;">
<span style="font-family: Verdana, sans-serif;"> factorial = factorial * i: <span style="color: #6aa84f;">//la primera iteración: factorial = 1 * i</span></span></div>
<div style="text-align: justify;">
<span style="font-family: Verdana, sans-serif;">Fin_Para</span></div>
</div>
<div style="text-align: justify;">
<span style="font-family: Verdana, sans-serif;"><br /></span></div>
<div style="text-align: justify;">
<span style="font-family: Verdana, sans-serif;">Para cualquier cálculo en que utilicemos acumuladores es absolutamente necesario inicializarlos correctamente, por lo general con el valor del elemento neutro de la operación de acumulación.</span></div>
<div style="text-align: justify;">
<br /></div>
MIPBhttp://www.blogger.com/profile/15144077089562468638noreply@blogger.com0tag:blogger.com,1999:blog-8606551171960007078.post-65726966361341227892014-10-02T09:03:00.001-07:002014-10-02T09:03:47.417-07:00Árboles binarios, un ejemplo prácticoMuchas veces nos es difícil entender para qué nos enseñan algo sin explicarnos la aplicación. El tiempo que llevo dando clases particulares he podido ver apuntes con mucho contenido y con pocos ejemplos prácticos, esto desmotiva mucho porque el estudiante piensa ¿Para qué me enseñan esto?.<br />
<br />
Esto pasa generalmente con el tema de árboles, te explican los tipos de árboles existen (binarios, múltiples, balanceados, etc) y cómo recorrerlos (pre-orden, post-orden, etc), sin embargo son muy pocos los ejemplos prácticos que he podido encontrar.<br />
<br />
El objetivo de este post es mostrar un ejemplo práctico en que se podría hacer uso de los árboles, aunque también se puede hacer uso de otras soluciones.<br />
<br />
Tenemos un fichero de texto que contiene en cada linea la edad de personas encuestadas para un estudio de mercado, lo que nos interesa es leer el fichero y mostrar en pantalla la cantidad de repeticiones por cada edad, es decir la edad que más se repiten en la muestra.<br />
<br />
Partimos de la premisa que la información no está ordenada y es una muestra de 1000 personas.<br />
<table>
<tbody>
<tr>
<td><div class="separator" style="clear: both; text-align: left;">
<a href="https://blogger.googleusercontent.com/img/b/R29vZ2xl/AVvXsEi3O-PkBgHprSAVYS78HBHICIdMk9s9Lv2dEfe-lTZdAMljz0t6sHwDCsEEaW7U6B9R9_D64gb-_qUKAeZ42dDYDcG62lqsRiX8EzFBwYka1MjCt_WSR42YCaiF0kAYOvMHQ7tSjD-SO7U/s1600/Muestra.jpg" imageanchor="1" style="margin-left: 1em; margin-right: 1em;"><img border="0" src="https://blogger.googleusercontent.com/img/b/R29vZ2xl/AVvXsEi3O-PkBgHprSAVYS78HBHICIdMk9s9Lv2dEfe-lTZdAMljz0t6sHwDCsEEaW7U6B9R9_D64gb-_qUKAeZ42dDYDcG62lqsRiX8EzFBwYka1MjCt_WSR42YCaiF0kAYOvMHQ7tSjD-SO7U/s1600/Muestra.jpg" height="320" width="80" /></a></div>
</td>
<td><br />
Utilizaremos para cada número una estructura (o clase) que almacene el valor de la edad y el valor de la repetición:<br />
<br />
<span style="font-family: Courier New, Courier, monospace;"><span style="color: blue;">public struct</span> <span style="color: #6aa84f;"><b>elemMuestra</b></span></span><br />
<span style="font-family: Courier New, Courier, monospace;">{</span><br />
<span style="font-family: Courier New, Courier, monospace;"><span class="Apple-tab-span" style="white-space: pre;"> </span><span style="color: blue;">public int</span> edad;</span><br />
<span style="font-family: Courier New, Courier, monospace;"><span class="Apple-tab-span" style="white-space: pre;"> </span><span style="color: blue;">public int</span> frecuencia;</span><br />
<span style="font-family: Courier New, Courier, monospace;">}</span><br />
<br />
El algoritmo que podríamos plantear es el siguiente:<br />
<br />
1. Leer número del fichero<br />
2. Buscar el número en la estructura ordenada<br />
2.1. Si el número existe en la estructura, incrementar el número de repeticiones<br />
2.1. Si el número NO existe en la estructura, inserto el número en la estructura<br />
3. Cuando termino de leer todos los números del fichero, imprimo cada número con su frecuencia de repetición guardada en la estructura.</td>
</tr>
</tbody></table>
<br />
En el punto 2 vemos que utilizamos una estructura ordenada, aquí podríamos utilizar un vector, una lista de punteros, un árbol binario,etc. lo importante es que<b> la estructura que definamos nos sea útil tanto para buscar si el número ya existe en la estructura, como para insertar un nuevo número en la estructura</b>.<br />
<br />
Si utilizamos un vector, podríamos realizar una <a href="http://algorithmmx.blogspot.com.es/2011/11/algoritmo-de-busqueda-binaria.html" target="_blank">búsqueda binaria</a>, debido a que los índices del vector ayudan a este tipo de búsqueda, sin embargo si utilizamos una lista de punteros o un árbol binario tendríamos que usar una búsqueda secuencial, pero sin duda el recorrido en un árbol podría ser mucho más eficiente que el recorrido en una lista de punteros, debido a que la forma del árbol no requiere recorrer a todos sus elementos sino que al tener un orden binario es como si realmente se hiciera una búsqueda binaria, a la búsqueda en un árbol binario se le llama <a href="http://es.wikipedia.org/wiki/%C3%81rbol_binario_de_b%C3%BAsqueda" target="_blank">búsqueda Silaina</a>.<br />
<br />
El otro punto a evaluar es el tema de la inserción, cuando ya sabemos que el número que hemos leído de fichero aún no existe en la estructura que hemos escogido, utilizar un vector podría ser lo menos eficiente, puesto que si tenemos ordenados 900 números en 20 edades distintas, y llega una nueva edad que es la menor de todas, debemos desplazar todas las edades a una casilla posterior para insertar la nueva edad de forma ordenada, ese desplazamiento puede ser muy costoso. En una lista de punteros la inserción es relativamente sencilla y en un árbol también.<br />
<br />
A nivel de programación los árboles son más fáciles de trabajar con funciones recursivas, por tanto si tenéis poca experiencia en funciones recursivas y la cantidad de elementos de la muestra no es tan grande, puede ser más sencillo de programar con vectores + búsqueda binaria o secuencial, sin embargo si veis que la muestra es muy grande y luego vais a realizar muchas búsquedas sobre la estructura cargada y ordenada es mejor trabajarla con árboles binarios + búsqueda sobre árboles binarios.<br />
<br />
Ahora bien, para que la búsqueda en un árbol binario sea aun más eficiente deberíamos lograr que el árbol tenga el menor numero de niveles, para esto se realiza lo que se llama el <a href="http://es.wikipedia.org/wiki/%C3%81rbol_AVL" target="_blank">balanceo de árboles</a>:<br />
<br />
<div class="separator" style="clear: both; text-align: center;">
<a href="https://blogger.googleusercontent.com/img/b/R29vZ2xl/AVvXsEg2xMT52VFb9nxOsZFLGAOmDBdFoc5R5jJy1yu9Ahhy8cplD-JKORnKAMdC3ALqNZCR5KUbAGNc6lW2BElEp3hm6gJqGPxGxXdMdY2shMH54EUm0y7kKF0fp4Hq_NlrQ6ggH03JpYEqIdU/s1600/arbol+binario+balanceado.jpg" imageanchor="1" style="margin-left: 1em; margin-right: 1em;"><img border="0" src="https://blogger.googleusercontent.com/img/b/R29vZ2xl/AVvXsEg2xMT52VFb9nxOsZFLGAOmDBdFoc5R5jJy1yu9Ahhy8cplD-JKORnKAMdC3ALqNZCR5KUbAGNc6lW2BElEp3hm6gJqGPxGxXdMdY2shMH54EUm0y7kKF0fp4Hq_NlrQ6ggH03JpYEqIdU/s1600/arbol+binario+balanceado.jpg" height="155" width="320" /></a></div>
<br />
<br />MIPBhttp://www.blogger.com/profile/15144077089562468638noreply@blogger.com2tag:blogger.com,1999:blog-8606551171960007078.post-30348084386063353682014-09-14T03:40:00.000-07:002014-09-14T03:41:11.620-07:00La importancia de pensarHace un tiempo hice un ejercicio de memoria para recordar exactamente qué fue lo que me motivó a ser Ing. Informática, la respuesta está en mi colegio, cuando tenia 8 años se introdujo una nueva asignatura que se llamaba "Computación", no era la primera vez que veía un ordenador (ya tenía uno en casa que sólo usaba para jugar), pero era la primera vez que aprendía a usar un ordenador para resolver problemas simples de matemáticas.<br />
<br />
El lenguaje que utilizábamos era el Pascal, la clase consistía en leer atentamente un problema y luego dibujar el diagrama de flujo para resolverlo, el profesor pasaba por cada uno de nuestros sitios según íbamos terminando y revisado el diagrama podíamos empezar a programar, nunca antes!! porque lo importante era que se validara que hubiéramos entendido lo que se pedía en el problema y que tengamos claro cómo lo íbamos a enfrentar. Lo más importante de esta clase era la metodología para solucionar los problemas, pensar y luego programar! tuve la suerte de caer en esa clase, fue la base fundamental para decantarme por la rama tecnológica.<br />
<br />
Ayer encontré un artículo muy interesante del <a href="http://blog.tiching.com/deberiamos-aprender-programar-en-las-escuelas/?utm_content=CMPImpresoras3D&utm_medium=referral&utm_campaign=cm&utm_source=twitter">Blog Tiching </a>en el que plantea los beneficios de que los niños aprendan a programar no solo para fomentar una orientación científica-tecnológica sino para que se acostumbren a estructurar el planteamiento de cualquier tipo de problema. Os recomiendo mucho leer el post, los beneficios de programar con metodología no sólo sirven en un campo puramente técnico sino que sirven para ejercitar y acostumbrarnos a entender los objetivos, plantear estrategias y ejecutar acciones para lograr a cumplir nuestros objetivos.<br />
<br />
Cada curso conozco alumnos diferentes, y a pesar de ser de distintos años de carrera, distintas edades e incluso diferentes carreras, todos creen que terminaremos la clase con un programa hecho, en realidad prácticamente no utilizamos el ordenador, lo que se llevan a casa son muchos papeles llenos de pseudocódigo y con las ideas muy claras: Objetivo y Estrategia, esa es la finalidad de la clase, teniendo estas dos cosas, la resolución sale sola.<br />
<br />
El próximo post será más técnico sólo quería hacer esta "pausa" por que es parte del aprendizaje entender que antes de programar se debe pensar.<br />
<br />
<br />MIPBhttp://www.blogger.com/profile/15144077089562468638noreply@blogger.com4tag:blogger.com,1999:blog-8606551171960007078.post-12341098339296036272014-08-01T10:19:00.000-07:002014-08-01T10:19:18.422-07:00Más acerca de booleanos<span style="font-family: Arial, Helvetica, sans-serif;">Como ya he comentado en uno de los primeros post <a href="http://ejemplosalgoritmos.blogspot.com.es/2013/03/las-variables-booleanas.html">Las Variables Booleanas</a> sólo toman dos valores: cierto o falso y su definición depende del lenguaje del programación.</span><br />
<span style="font-family: Arial, Helvetica, sans-serif;"><br /></span>
<span style="font-family: Arial, Helvetica, sans-serif;">En este post veremos que podemos utilizar variables de tipo entero que cumplan la misma función, asumiendo que sólo podrán tomar dos valores (dos números). En C++ se utilizan con mayor frecuencia los enteros porque el mismo lenguaje asume que el valor 0 hace la función de <i>falso </i>y el valor distinto de 0 hace la función de <i>cierto.</i></span><br />
<span style="font-family: Arial, Helvetica, sans-serif;"><br /></span>
<span style="font-family: Arial, Helvetica, sans-serif;">Por ejemplo, el siguiente programa utiliza la variable <b>i</b> para mostrar una cuenta regresiva desde 10 hasta 1 y también sirve como <b>variable de condición de salida</b> para el while:</span><br />
<br />
<span style="font-family: Courier New, Courier, monospace;">int main()</span><br />
<span style="font-family: Courier New, Courier, monospace;">{</span><br />
<span style="font-family: Courier New, Courier, monospace;"> <span style="color: #38761d; font-size: x-small;"><b>//variable i sirve para la impresión y como tope del while</b></span></span><br />
<span style="font-family: Courier New, Courier, monospace;"> int i = 10;</span><br />
<span style="font-family: Courier New, Courier, monospace;"> </span><br />
<span style="color: #38761d; font-family: Courier New, Courier, monospace;"> <b><span style="font-size: x-small;">//poniendo simplemente la i como condición significa que </span></b></span><br />
<span style="color: #38761d; font-family: Courier New, Courier, monospace;"><b><span style="font-size: x-small;"> //iterará <i>mientras </i>la variable i sea diferente de cero</span></b></span><br />
<span style="font-family: Courier New, Courier, monospace;"> while(i)</span><br />
<span style="font-family: Courier New, Courier, monospace;"> {</span><br />
<span style="font-family: Courier New, Courier, monospace;"> cout << "i = " << i << endl; </span><br />
<span style="font-family: Courier New, Courier, monospace;"> i--;<span style="color: #38761d; font-size: x-small;"><b>//decrementa i hasta que llega a 0 y sale del bucle</b></span></span><br />
<span style="font-family: Courier New, Courier, monospace;"> }</span><br />
<span style="font-family: Courier New, Courier, monospace;"> return 0;</span><br />
<br />
<span style="font-family: Courier New, Courier, monospace;">}</span><br />
<div>
<br /></div>
<div>
<span style="font-family: Arial, Helvetica, sans-serif;">La salida del programa es esta:</span></div>
<div>
<br /></div>
<div>
<pre>i = 10
i = 9
i = 8
i = 7
i = 6
i = 5
i = 4
i = 3
i = 2
i = 1</pre>
<pre><span style="font-family: Arial, Helvetica, sans-serif;">
</span></pre>
<span style="font-family: Arial, Helvetica, sans-serif;">Con esto podemos ver que es muy importante conocer las capacidades de cada lenguaje de programación para que se adapten mejor a una solución o a un estilo de programar.</span><br />
<pre><span style="font-family: Arial, Helvetica, sans-serif;">
</span></pre>
<span style="font-family: Arial, Helvetica, sans-serif;">Ahora mostraré otro ejemplo en C++ en el que utilizaré la lógica inversa. El siguiente programa muestra un bucle que itera siempre que la condición <i>No sea igual a 0, </i>para eso se utiliza el símbolo <b>!</b> que invierte el valor de la variable evaluada:</span><br />
<pre><span style="font-family: Arial, Helvetica, sans-serif;">
</span></pre>
<pre><span style="font-family: Courier New, Courier, monospace;">int main()
{
<span style="color: #38761d; font-size: x-small;"> <b>//variable i se inicializa con valor 0 (falso)</b></span></span></pre>
<pre><span style="font-family: Courier New, Courier, monospace;"> int i = 0;
<span style="color: #38761d; font-size: x-small;"> <b>//Itera mientras el resultado de la parte entera de la división sea igual a 0</b></span>
while(<b><span style="color: blue;">!</span></b>(i/3))
{
cout << "i = " << i << endl;
i++;
}
return 0;
}
</span></pre>
<div>
<span style="font-family: Arial, Helvetica, sans-serif;"><br /></span></div>
<div>
<span style="font-family: Arial, Helvetica, sans-serif;">La salida del programa es esta:</span></div>
<div>
<span style="font-family: Arial, Helvetica, sans-serif;"><br /></span></div>
<div>
<pre>i = 0
i = 1
i = 2</pre>
<pre>
</pre>
<pre>
</pre>
</div>
<span style="font-family: Arial, Helvetica, sans-serif;">En conclusión, sabemos que para las instrucciones condicionales y los bucles tenemos la opción de utilizar booleanos, expresiones lógicas y dependiendo del lenguaje de programación también números enteros.</span><br />
<pre><span style="font-family: Arial, Helvetica, sans-serif;">
</span></pre>
<pre><span style="font-family: Arial, Helvetica, sans-serif;">
</span></pre>
<pre><span style="font-family: Arial, Helvetica, sans-serif;">
</span></pre>
<pre><span style="font-family: Arial, Helvetica, sans-serif;">
</span></pre>
</div>
MIPBhttp://www.blogger.com/profile/15144077089562468638noreply@blogger.com0tag:blogger.com,1999:blog-8606551171960007078.post-26195899322306463062014-07-20T01:50:00.004-07:002014-07-20T01:50:51.355-07:00Algo de matrices<span style="font-family: Arial, Helvetica, sans-serif;">Una de las dificultades más comunes son los vectores, sobretodo comprender la diferencia entre el indice de un vector (posición) y el valor contenido en el índice del vector (datos).</span><br />
<span style="font-family: Arial, Helvetica, sans-serif;"><br /></span>
<span style="font-family: Arial, Helvetica, sans-serif;">Para complicarlo aún más viene el tema de las matrices, que no son más que vectores pero en dos dimensiones, esto es que ahora el índice está formado por dos posiciones.</span><br />
<span style="font-family: Arial, Helvetica, sans-serif;"><br /></span>
<span style="font-family: Arial, Helvetica, sans-serif;">Sobre teoría de matrices se ha escrito mucho, lo que pretendo en este post es simplemente mostrar como acceder a una matriz y determinar si es una matriz identidad o no (<a href="http://es.wikipedia.org/wiki/Matriz_identidad">¿Qués es una matriz identidad?</a>). Para este fin utilizaremos el recorrido secuencial de una matriz fila a fila y para cada elemento de la fila veremos si tiene el valor correcto que le corresponde a la matriz identidad (1 en la diagonal y 0 en el resto de campos):</span><br />
<br />
<span style="font-family: Courier New, Courier, monospace;">int esIdentidad = 1; <b style="color: #38761d;">//variable que indica si la matriz es identidad o no</b></span><br />
<span style="font-family: Courier New, Courier, monospace;">int x, y = 0; <b><span style="color: #38761d;">//indice de filas y columnas</span></b></span><br />
<span style="font-family: Courier New, Courier, monospace;">int N=10;<span style="color: #38761d;"><b>//dimensión de la matriz</b></span></span><br />
<span style="font-family: Courier New, Courier, monospace;"><br /></span>
<b><span style="color: #38761d; font-family: Courier New, Courier, monospace;">//se asumen que la matriz es de Identidad hasta que se muestre que tenga un valor incorrecto</span></b><br />
<span style="font-family: Courier New, Courier, monospace;">while(esidentidad)</span><br />
<span style="font-family: Courier New, Courier, monospace;">{</span><br />
<span style="font-family: Courier New, Courier, monospace;"> <b><span style="color: #38761d;"> //recorre todos los elementos de la fila hasta que encuentre algún error o termine la fila</span></b></span><br />
<span style="font-family: Courier New, Courier, monospace;"> for(int y=0; y<N && esIdentidad; y++)</span><br />
<span style="font-family: Courier New, Courier, monospace;"> {</span><br />
<span style="font-family: Courier New, Courier, monospace;"> <b><span style="color: #38761d;">//la diagonal debe tener el valor 1, en caso contrario no puede ser una matriz Identidad</span></b></span><br />
<span style="font-family: Courier New, Courier, monospace;"> if(x==y && Matriz[x][y] !=1) esidentidad = 0;</span><br />
<span style="font-family: Courier New, Courier, monospace;"> <b><span style="color: #38761d;">//los que no están en la diagonal deben ser 0, en caso contrario no puede ser una matriz identidad</span></b></span><br />
<span style="font-family: Courier New, Courier, monospace;"> if(x!=y && Matriz[x][y] !=0) esidentidad = 0;</span><br />
<span style="font-family: Courier New, Courier, monospace;"> }</span><br />
<span style="font-family: Courier New, Courier, monospace;"> x++;<b><span style="color: #38761d;">//cada iteración del while se corresponde con cada fila de la matriz </span></b></span><br />
<span style="font-family: Courier New, Courier, monospace;">}</span><br />
<span style="font-family: Courier New, Courier, monospace;"><br /></span>
<b><span style="color: #38761d; font-family: Courier New, Courier, monospace;">//resultado de la evaluación</span></b><br />
<span style="font-family: Courier New, Courier, monospace;">if(esIdentidad) print("La matriz es identidad");</span><br />
<span style="font-family: Courier New, Courier, monospace;">else print("La matriz no es identidad");</span><br />
<span style="font-family: Courier New, Courier, monospace; font-size: x-small;"><br /></span>
<span style="font-family: Courier New, Courier, monospace; font-size: x-small;"><br /></span>
<span style="font-family: Arial, Helvetica, sans-serif;">Vemos que el el indice de la matriz está compuesto por dos posiciones: <b><i>x</i></b> e <b><i>y</i></b>.</span><br />
<span style="font-family: Arial, Helvetica, sans-serif;">Vemos que el valor en una posición determinada de la matriz se accede a través de las posiciones: <i><b>Matriz[x][y].</b></i></span><br />
<span style="font-family: Arial, Helvetica, sans-serif;">Vemos que cuando encuentra un valor que no se corresponde con la matriz identidad cambia la variable <i><b>esIdentidad </b></i>para salir inmediatamente de los bucles for y while, puesto que al primer valor incorrecto no hace falta seguir recorriendo la matriz, ya sabemos que no es de Identidad.</span><br />
<span style="font-family: Arial, Helvetica, sans-serif;">Vemos que para recorrer una matriz hace falta 2 bucles anidados, en este caso el while recorre las filas de la matriz y el for recorre las columnas para cada fila.</span><br />
<br />
<br />
<br />MIPBhttp://www.blogger.com/profile/15144077089562468638noreply@blogger.com0tag:blogger.com,1999:blog-8606551171960007078.post-42978003047030626342014-03-23T02:56:00.000-07:002014-03-23T02:56:55.139-07:00RecursividadSe dice que una función es recursiva cuando su ecuación de solución se utiliza a si misma para resolverse.<br />
<br />
Un ejemplo típico de recursividad es la función Factorial, sabemos que el Factorial de un numero es igual al producto de dicho número multiplicado por el factorial del número anterior:<br />
<br />
Factorial(4) = 4 * Factorial(3)<br />
<br />
Vemos que está definiendo la solución del factorial empleando la misma fórmula del factorial, puesto que:<br />
<br />
Factorial(3) = 3 * Factorial(2)<br />
Factorial(2) = 2 * Factorial(1)<br />
....<br />
<br />
Pero, ¿Cuándo termina la recursividad? Es absolutamente necesario definir lo que se llama un TOPE, que es cuando la recursividad termina, sino seguiríamos hasta el infinito.<br />
<br />
Para el caso del ejemplo típico del factorial, se sabe que esta función se aplica a un conjunto de números enteros mayores o iguales a 0, del cual Factorial(0) = 1, siendo esta fórmula la única que no utiliza la recursividad para su definición, por tanto:<br />
<br />
<i><span style="color: blue;"><b>Toda función recursiva necesita un TOPE, dicho tope es una de la soluciones de la función que no se define por si misma.</b></span></i><br />
<br />
Si generalizamos podemos decir que, Para toda N tal que N>=0, Factorial(N) se resuelve con las siguientes ecuaciones:<br />
<br />
Si N=0, Factorial(N) = 1<br />
Si N>0, Factorial(N) = N * Factorial(N-1)<br />
Para cualquier otro valor de N, No existe conjunto solución para Factorial(N)<br />
<br />
Otra característica importante de una función recursiva es que al llamarse a si misma los parámetros deben variar, sino entrará en bucle infinito, por ejemplo esto sería un error:<br />
<br />
Factorial(N) = N * Factorial(N) ---> En este caso caerá en bucle infinito porque NUNCA llegará al TOPE<br />
<br />
Por tanto:<br />
<b><br /></b>
<i><span style="color: blue;"><b>En toda función recursiva es necesario que la llamada si misma garantice que en algún punto llegará al TOPE. </b></span></i><br />
<i><br /></i>
<span style="color: #38761d;">//ejemplo de función recursiva</span><br />
<span style="color: #38761d;">//asumimos que el valor N que ingresa es >=0</span><br />
int factorial (int N)<br />
{<br />
<span style="color: #38761d;"> //lo primero que definimos en una función recursiva el el TOPE</span><br />
if(N == 0) return 1;<br />
<span style="color: #38761d;">//La llamada recursiva con N-1 asegura que en algún momento llegará a ejecutar factorial(0)</span><br />
return N * Factorial(N-1);<br />
}<br />
<br />
<i><br /></i>
<i>¿Por qué es importante definir el tope al principio?</i><br />
<i>¿Podríamos utilizar la operación unaria -- para llamar de forma recursiva: Factorial(N--)?</i><br />
<i><br /></i>
<i><br /></i>
<i><br /></i>
<i><br /></i>
<i><br /></i>
<i><br /></i>
<i><br /></i>
<i><br /></i>
<i><br /></i>
<i><br /></i>MIPBhttp://www.blogger.com/profile/15144077089562468638noreply@blogger.com1tag:blogger.com,1999:blog-8606551171960007078.post-82496121198674088242014-02-09T10:06:00.001-08:002014-02-09T11:52:57.977-08:00Inserción de valores en un vector ordenadoEn esta ocasión trabajaremos una estructura fija (vector) como si fuese una estructura variable, esta solución se puede aplicar en escenarios en los cuales sabemos que:<br />
<br />
- Como máximo utilizaremos un número determinado de elementos.<br />
- La inicialización (inserción) se realiza una vez o con muy poca frecuencia,<br />
- Y se necesita acceder continuamente a elementos en concreto.<br />
<br />
Por ejemplo, sabemos que en un aula no se puede exceder de los 100 alumnos, la matrícula se realiza al principio de curso y durante el curso se puede acceder en cualquier momento al expediente de cualquiera de los alumnos matriculados.<br />
En un aula podrían inscribirse 25 alumnos y en otra 82 alumnos, si se quisiera imprimir un listado de los alumnos matriculados en cada aula no es necesario recorrer el vector de 100 elementos, sino que en el primero se recorrerá 25 veces y en el segundo 82.<br />
<br />
Para hacer uso de los vectores de esta forma utilizaremos una variable auxiliar que representará el número de elementos utilizados, así cada vez que necesitemos hacer una operación sobre todos los elementos no recorreremos todos los elementos del vector sino todos los utilizados.<br />
<br />
int listaOrdenada[N];<br />
int numelem = 0; <span style="color: #38761d;">//cantidad de elementos ocupados de la lista</span><br />
<div>
<br /></div>
Ahora complicaremos un poco el problema y suponemos que los alumnos cuando se matricula no vienen de forma ordenada, pero se requiere almacenarlos de forma ordenada por apellido, esto implica que cada vez que se agrega un alumno a la lista de matriculados se debe buscar la posición del vector en la cual se debe insertar, no siempre será el último.<br />
<br />
Este tipo de problema utiliza varios de los conceptos vistos en entradas anteriores, tales como:<br />
<br />
- El uso de vectores para almacenar información del mismo tipo.<br />
- El uso de vectores como estructura que ocupa un espacio de memoria fija de la cuál sólo utilizaremos una parte de forma dinámica.<br />
- El uso de los iteradores for y while para realizar una acción sobre cada elemento de un vector.<br />
- Recorridos de vectores en forma ascendente y en forma descendente<br />
- El uso de comprador if para determinar la posición en la cual se debe insertar el nuevo elemento.<br />
<br />
Para simplificar el problema supondremos que los alumnos son números enteros y sus apellidos son números mayores que cero y os invito a que modifiquéis el código para adaptarlo a un vector de una estructura de alumnos que incluya los nombres y los apellidos.<br />
<br />
Os dejo el código a continuación en C:<br />
<br />
#include <stdio.h><br />
#include <stdlib.h><br />
#define N 100<br />
<br />
<br />
int main(int argc, char *argv[])<br />
{<br />
<span style="color: #38761d;">//definición de variables</span><br />
int listaOrdenada[N];<br />
int numelem = 0; <span style="color: #38761d;">//cantidad de elementos ocupados de la lista</span><br />
int numero;<br />
int i, j;<br />
<span style="color: #38761d;"> //inicializa vector</span><br />
for(i=0; i<N; i++) listaOrdenada[i] = 0;<br />
<br />
<span style="color: #38761d;">//proceso</span><br />
<span style="color: #38761d;"> //mensajes iniciales</span><br />
printf("Ingrese los numeros de la lista \n\nLos numeros deben ser mayores que 0 \nPara introducir pulse <ENTER> \n");<br />
printf("como maximo puede ingresar %d numeros \n", N);<br />
printf("Para finalizar pulse 0 y <ENTER>\n");<br />
<br />
<span style="color: #38761d;">//Lee valor a ingresar en el vector</span><br />
<span style="color: #38761d;"> </span>printf("Numero: ");<br />
scanf("%d", &numero);<br />
printf("Numero ingresado %d \n", numero);<br />
<br />
while(numero != 0 && numelem < N)<br />
{<br />
i = 0;<br />
<span style="color: #38761d;"> //ubica la posición para insertar el número</span><br />
while(i<numelem && listaOrdenada[i] < numero) i++;<br />
<span style="color: #38761d;">//en el caso que se inserte en la última posición: i == numelem</span><br />
if(i==numelem) {<br />
listaOrdenada[i]=numero;<br />
numelem++;<br />
}<br />
else{<br />
<span style="color: #38761d;"> //tiene que desplazar a todos los elementos posteriores</span><br />
j = numelem;<br />
numelem++;<br />
<span style="color: #38761d;"> //recorre la lista de forma inversa para desplazar los valores</span><br />
while(j>i){<br />
listaOrdenada[j] = listaOrdenada[j-1];<br />
j--;<br />
}<br />
listaOrdenada[i] = numero;<br />
}<br />
<br />
<span style="color: #38761d;">//imprime la lista de elementos </span><br />
for(i=0; i<numelem; i++) printf("%d \t",listaOrdenada[i]);<br />
<br />
printf("\n\nNumero: ");<br />
scanf("%d", &numero);<br />
printf("Numero ingresado %d \n", numero);<br />
<br />
}<br />
<br />
printf("Elementos utilizados: %d \n", numelem);<br />
<br />
system("PAUSE");<span class="Apple-tab-span" style="white-space: pre;"> </span><br />
return 0;<br />
}<br />
<div>
<br /></div>
<div>
<br /></div>
<div>
<br /></div>
MIPBhttp://www.blogger.com/profile/15144077089562468638noreply@blogger.com0tag:blogger.com,1999:blog-8606551171960007078.post-59119187237058094492014-01-21T13:07:00.001-08:002014-01-21T13:08:01.612-08:00Listas dinámicas<div style="margin-bottom: 0cm;">
<span style="font-size: 11pt;">La
manera más práctica de trabajar con una lista de objetos del mismo
tipo es un Vector (o Array), cuando se instancia un vector se está
reservando en memoria una cantidad fija de bytes para almacenar la
información, así si tenemos:</span></div>
<div style="margin-bottom: 0cm;">
<br /></div>
<div style="margin-bottom: 0cm;">
<span style="font-size: 11pt;">int
myList[5]; <span style="color: #38761d;">//reserva espacio para 5 variables de tipo int</span></span></div>
<div style="margin-bottom: 0cm;">
<span style="font-size: 11pt;">myList[0]
= 1; <span style="color: #38761d;">//almacena el valor 1 en la primera posición del vector</span></span></div>
<div style="margin-bottom: 0cm;">
<br /></div>
<div style="margin-bottom: 0cm;">
<span style="font-size: 11pt;">Ahora
utilizaré un ejemplo de un problema tipo de examen, habla sobre el
registro de reclamaciones de un comercio, cada reclamación debe
contener:</span></div>
<ul>
<li><div style="margin-bottom: 0cm;">
<span style="font-size: 11pt;">El
nombre de la persona que realiza la reclamación</span></div>
</li>
<li><div style="margin-bottom: 0cm;">
<span style="font-size: 11pt;">La
fecha de la reclamación</span></div>
</li>
<li><div style="margin-bottom: 0cm;">
<span style="font-size: 11pt;">La
descripción de la reclamación</span></div>
</li>
<li><div style="margin-bottom: 0cm;">
<span style="font-size: 11pt;">El
estado de la reclamación: 0 si está abierta, 1 si está resuelta.</span></div>
</li>
</ul>
<div style="margin-bottom: 0cm;">
<br /></div>
<div style="margin-bottom: 0cm;">
<span style="font-size: 11pt;">Para
representar una reclamación podemos utilizar una estructura de este
tipo:</span></div>
<div style="margin-bottom: 0cm;">
<br /></div>
<div style="margin-bottom: 0cm;">
<span style="font-size: 11pt;">typedef
struct reclamacion</span></div>
<div style="margin-bottom: 0cm;">
<span style="font-size: 11pt;">{</span></div>
<div style="margin-bottom: 0cm;">
<span style="font-size: 11pt;">String
nombrePersona;</span></div>
<div style="margin-bottom: 0cm;">
<span style="font-size: 11pt;">Date
fechaReclamacion;</span></div>
<div style="margin-bottom: 0cm;">
<span style="font-size: 11pt;">String
descripcion;</span></div>
<div style="margin-bottom: 0cm;">
<span style="font-size: 11pt;">int
estado;</span></div>
<div style="margin-bottom: 0cm;">
<span style="font-size: 11pt;">}Reclamacion;</span></div>
<div style="margin-bottom: 0cm;">
<br /></div>
<div style="margin-bottom: 0cm;">
<span style="font-size: 11pt;">Ahora
creamos un Vector para almacenar la lista de reclamaciones:</span></div>
<div style="margin-bottom: 0cm;">
<span style="font-size: 11pt;">Reclamacion
Lista[100]; <span style="color: #38761d;">//vector de capacidad para 100 reclamaciones</span></span></div>
<div style="margin-bottom: 0cm;">
<br /></div>
<div style="margin-bottom: 0cm;">
<span style="font-size: 11pt;">Pero,
y ¿Qué pasa si hay más de 100 reclamaciones?</span></div>
<div style="margin-bottom: 0cm;">
<br /></div>
<div style="margin-bottom: 0cm;">
<span style="font-size: 11pt;">Cuando
no sabemos la dimensión que puede tomar una lista lo mejor es
reservar memoria de forma dinámica, para eso podemos utilizar los
punteros.</span></div>
<div style="margin-bottom: 0cm;">
<br /></div>
<div style="margin-bottom: 0cm;">
<span style="font-size: 11pt;">Así,
sólo creamos una variable de tipo puntero que apunte a la
estructura, y modificamos la estructura para que apunte al siguiente
elemento de la lista, así;</span></div>
<div style="margin-bottom: 0cm;">
<br /></div>
<div style="margin-bottom: 0cm;">
<span style="font-size: 11pt;">typedef
struct reclamacion</span></div>
<div style="margin-bottom: 0cm;">
<span style="font-size: 11pt;">{</span></div>
<div style="margin-bottom: 0cm;">
<span style="font-size: 11pt;">String
nombrePersona;</span></div>
<div style="margin-bottom: 0cm;">
<span style="font-size: 11pt;">Date
fechaReclamacion;</span></div>
<div style="margin-bottom: 0cm;">
<span style="font-size: 11pt;">String
descripcion;</span></div>
<div style="margin-bottom: 0cm;">
<span style="font-size: 11pt;">int
estado;</span></div>
<div style="margin-bottom: 0cm;">
<span style="font-size: 11pt;">struct
reclamacion * siguiente;<span style="color: #38761d;"> //este puntero apunta a la siguiente
reclamación</span></span></div>
<div style="margin-bottom: 0cm;">
<span style="font-size: 11pt;">}Reclamacion;</span></div>
<div style="margin-bottom: 0cm;">
<br /></div>
<div style="margin-bottom: 0cm;">
<span style="font-size: 11pt;">Reclamacion
* listaReclamaciones; </span>
</div>
<div style="margin-bottom: 0cm;">
<span style="font-size: 11pt;">listaReclamaciones
= NULL; <span style="color: #38761d;">//inicializamos el puntero a NULL hasta que empiecen a llegar
las reclamaciones</span></span></div>
<div style="margin-bottom: 0cm;">
<br /></div>
<div style="margin-bottom: 0cm;">
<span style="color: #38761d; font-size: 11pt;">//creamos
la primera reclamación</span></div>
<div style="margin-bottom: 0cm;">
<span style="font-size: 11pt;">Reclamacion
* rec1 = new Reclamacion;</span></div>
<div style="margin-bottom: 0cm;">
rec1.<span style="font-size: 11pt;">nombrePersona
= “Juan”;</span></div>
<div style="margin-bottom: 0cm;">
<span style="font-size: 11pt;">rec1.fechaReclamacion
= new Date(); <span style="color: #38761d;">//representa que toma la fecha actual (esto varía
según el lenguaje de programación)</span></span></div>
<div style="margin-bottom: 0cm;">
<span style="font-size: 11pt;">rec1.descripcion
= “ejemplo de reclamacion1”;</span></div>
<div style="margin-bottom: 0cm;">
<span style="font-size: 11pt;">rec1.estado
= 0; <span style="color: #38761d;">//lo inicializa a 0 porque cuando se crea está abierta</span></span></div>
<div style="margin-bottom: 0cm;">
<span style="font-size: 11pt;">rec1->siguiente
= NULL;<span style="color: #38761d;"> //inicializa a NULL porque es un puntero</span></span></div>
<div style="margin-bottom: 0cm;">
<br /></div>
<div style="margin-bottom: 0cm;">
<span style="font-size: 11pt;">Ahora
para agregar la primera reclamación a la lista hacemos que la
variable listaReclamaciones ya no apunte a NULL sino que apunte al
elemento rec1:</span></div>
<div style="margin-bottom: 0cm;">
<br /></div>
<div style="margin-bottom: 0cm;">
<span style="font-size: 11pt;">listaReclamaciones
= rec1;</span></div>
<div style="margin-bottom: 0cm;">
<br /></div>
<div style="margin-bottom: 0cm;">
<span style="font-size: 11pt;">Para
el caso de una segunda reclamación es distinto y dependerá
si se quiere agregar al principio de la lista o al final de la lista,
vamos a agregarlo al final, así listaReclamaciones apuntará a rec1
y rec1->siguiente apuntará a rec2:</span></div>
<div style="margin-bottom: 0cm;">
<br /></div>
<div style="margin-bottom: 0cm;">
<span style="color: #38761d; font-size: 11pt;">//creamos
la segunda reclamación</span></div>
<div style="margin-bottom: 0cm;">
<span style="font-size: 11pt;">Reclamacion
* rec2 = new Reclamacion;</span></div>
<div style="margin-bottom: 0cm;">
rec2.<span style="font-size: 11pt;">nombrePersona
= “Pedro”;</span></div>
<div style="margin-bottom: 0cm;">
<span style="font-size: 11pt;">rec2.fechaReclamacion
= new Date(); </span></div>
<div style="margin-bottom: 0cm;">
<span style="font-size: 11pt;">rec2.descripcion
= “ejemplo de reclamacion2”;</span></div>
<div style="margin-bottom: 0cm;">
<span style="font-size: 11pt;">rec2.estado
= 0; </span></div>
<div style="margin-bottom: 0cm;">
<span style="font-size: 11pt;">rec2->siguiente
= NULL; </span></div>
<div style="margin-bottom: 0cm;">
<br /></div>
<div style="margin-bottom: 0cm;">
<span style="font-size: 11pt;">Si
hacemos:</span></div>
<div style="margin-bottom: 0cm;">
<span style="font-size: 11pt;">listaReclamaciones->siguiente
= rec2; //es lo mismo que rec1->siguiente = rec2</span></div>
<div style="margin-bottom: 0cm;">
<br /></div>
<div style="margin-bottom: 0cm;">
<span style="font-size: 11pt;">Tenemos
el problema resuelto, rec1->siguiente ya no apunta a NULL sino que
apunta a rec2 y rec2 es la última de la lista.</span></div>
<div style="margin-bottom: 0cm;">
<br /></div>
<div style="margin-bottom: 0cm;">
<span style="font-size: 11pt;">¿Y
que pasa si no sabemos la cantidad de elementos que tiene la lista y
queremos agregar un elemento al final?</span></div>
<div style="margin-bottom: 0cm;">
<span style="font-size: 11pt;">La
solución es tomar un puntero auxiliar y desplazamos hasta el último
elemento de la lista y hacer que este último elemento apunte al
elemento nuevo que queremos agregar a la lista:</span></div>
<div style="margin-bottom: 0cm;">
<br /></div>
<div style="margin-bottom: 0cm;">
<span style="color: #38761d; font-size: 11pt;">//puntero
auxiliar que se desplaza hasta el último elemento</span></div>
<div style="margin-bottom: 0cm;">
<span style="font-size: 11pt;">Reclamacion
* pAuxiliar = listaReclamaciones; //se inicializa apuntando al
primero de la lista</span></div>
<div style="margin-bottom: 0cm;">
<br /></div>
<div style="margin-bottom: 0cm;">
<span style="color: #38761d; font-size: 11pt;">//mientras
el siguiente del auxiliar es distinto a nulo, avanza el puntero al
siguiente elemento, hasta llegar al último</span></div>
<div style="margin-bottom: 0cm;">
<span style="font-size: 11pt;">while(pAuxiliar->siguiente
!= NULL) pAuxiliar = pAuxiliar->siguiente;</span></div>
<div style="margin-bottom: 0cm;">
</div>
<div style="margin-bottom: 0cm;">
<span style="color: #38761d; font-size: 11pt;">//ahora
agregamos el nuevo elemento al final de la lista</span></div>
<div style="margin-bottom: 0cm;">
<span style="font-size: 11pt;">pAuxiliar->
siguiente = nuevaRec; <span style="color: #38761d;">//nuevaRec es el nuevo elemento de tipo
reclamacion*</span></span></div>
<div style="margin-bottom: 0cm;">
<br /></div>
<div style="margin-bottom: 0cm;">
<span style="font-size: 11pt;">Existen
muchas variantes:</span></div>
<br />
<ul>
<li><div style="margin-bottom: 0cm;">
<span style="font-size: 11pt;">agregar
el elemento al inicio de la lista</span></div>
</li>
<li><div style="margin-bottom: 0cm;">
<span style="font-size: 11pt;">agregar
el elemento en medio de la lista (por ejemplo para una lista
ordenada)</span></div>
</li>
</ul>
<div>
<span style="font-size: 15px;"><br /></span></div>
<div>
<span style="font-size: 15px;"><br /></span></div>
MIPBhttp://www.blogger.com/profile/15144077089562468638noreply@blogger.com0tag:blogger.com,1999:blog-8606551171960007078.post-4711007720907366042013-11-30T09:05:00.000-08:002013-11-30T09:05:39.799-08:00Representación de un puntero en memoriaLa representación de la memoria para una variable de tipo int se puede entender de forma muy simple, en tiempo de ejecución cuando las variable se crean se les asigna un espacio físico en memoria, así cuando vemos:<br />
<br />
<span style="color: #38761d;">//se define la variable a de tipo int</span><br />
int a;<br />
<br />
La variable a tiene reservado un espacio para almacenar su contenido (el valor de la variable) y se sabe que ese contenido tiene que ser de tipo int porque así ha sido definida.<br />
<br />
Sin embargo, cuando utilizamos variables de tipo punteros la comprensión de la asignación de la memoria es un poco más complicada, una variable de tipo puntero tiene en su definición "al menos un *", aquí unos ejemplos:<br />
<br />
int * b;<br />
int **c;<br />
<br />
Cuando se reserva memoria para un puntero, se separa un espacio de memoria pero el contenido debe tener el formato de una dirección de memoria. si tomamos como ejemplo:<br />
<br />
int * b;<br />
<br />
El primer paso es identificar el nombre de la variable y el tipo de la variable:<br />
<br />
nombre de variable: b<br />
tipo de la variable: int *<br />
<br />
como el tipo de la variable contiene "al menos un *" entonces el contenido (el valor) tiene el formato de una dirección, esa dirección debe apuntar al tipo de variable al cual apunta.<br />
<br />
Para saber el tipo de variable al cual apunta, seguimos el segundo paso, que consiste en leer la misma definición de la variable pero ahora el * pasa a ser parte del nombre de la variable:<br />
<br />
nombre de variable: *b<br />
tipo de la variable: int<br />
<div>
<br /></div>
<div>
Ahora vemos que la dirección a la que apunta el contenido de b (el valor de b) apunta a una dirección de memoria cuyo nombre se puede interpretar como *b y cuyo tipo es int.</div>
<div>
<br /></div>
<div>
Para verlo de una forma más práctica representaremos las siguientes líneas de código:</div>
<div>
<br /></div>
<div>
int a = 5:</div>
<div>
<span style="color: #38761d;">//reserva memoria para el puntero, esta asignación varía según el lenguaje de programación</span></div>
<div>
int* b = new int(); </div>
<div>
*b = 3;</div>
<br />
En una tabla:<br />
<div class="separator" style="clear: both; text-align: center;">
<a href="https://blogger.googleusercontent.com/img/b/R29vZ2xl/AVvXsEgRKx-BYOD5Fo-iyKUR3Uc4n1AzaCDRev3prH4fyMaKtp9stOf9aCZgofpPQshrWqwFMVHnFgf4fPW3PKne7H_-TQqah9_e3T_kNtJtv_0S2fY_Z7O2SDfTfdOFXCxBDb-WdaWRmhyphenhyphenrKYM/s1600/Blog_1.bmp" imageanchor="1" style="margin-left: 1em; margin-right: 1em;"><img border="0" src="https://blogger.googleusercontent.com/img/b/R29vZ2xl/AVvXsEgRKx-BYOD5Fo-iyKUR3Uc4n1AzaCDRev3prH4fyMaKtp9stOf9aCZgofpPQshrWqwFMVHnFgf4fPW3PKne7H_-TQqah9_e3T_kNtJtv_0S2fY_Z7O2SDfTfdOFXCxBDb-WdaWRmhyphenhyphenrKYM/s1600/Blog_1.bmp" height="104" width="640" /></a></div>
<br />
Podemos ver que para la variable b el contenido es la dirección 0003, y en la dirección 3 se encuentra la variable *b de tipo int en la que se guarda el contenido 3.<br />
<br />
Podríamos aprovechar el espacio de memoria de a para guardar el contenido de b:<br />
<br />
int a = 5;<br />
int* b;<br />
*b = a; <span style="color: #38761d;">//*b y a son del mismo tipo por eso se puede realizar la instrucción de asignación.</span><br />
<br />
La representación en la tabla de memoria sería:<br />
<br />
<div class="separator" style="clear: both; text-align: center;">
<a href="https://blogger.googleusercontent.com/img/b/R29vZ2xl/AVvXsEi-sj2S8fQeLsQp3aiZ9ZHRxq4RiSyYNsKhyaqGEqytN3xvcoUqzfoQkjSacdwIUjLxnseP7NzWOHpscyr8Gfi8XMBDhMyfBOHHtBDtxJ3FoCAMciECcQnnnBiGEshtvEMi3PzdRhIcyoM/s1600/Blog_2.bmp" imageanchor="1" style="margin-left: 1em; margin-right: 1em;"><img border="0" src="https://blogger.googleusercontent.com/img/b/R29vZ2xl/AVvXsEi-sj2S8fQeLsQp3aiZ9ZHRxq4RiSyYNsKhyaqGEqytN3xvcoUqzfoQkjSacdwIUjLxnseP7NzWOHpscyr8Gfi8XMBDhMyfBOHHtBDtxJ3FoCAMciECcQnnnBiGEshtvEMi3PzdRhIcyoM/s1600/Blog_2.bmp" height="106" width="640" /></a></div>
<br />
Podemos ver que en este caso: a y *b están en la misma dirección de memoria.<br />
<br />
<br />
<br />
<br />
<br />MIPBhttp://www.blogger.com/profile/15144077089562468638noreply@blogger.com0tag:blogger.com,1999:blog-8606551171960007078.post-69889336678845589852013-10-19T01:49:00.002-07:002013-10-19T01:50:46.958-07:00Estructuras (Struct)Cuando programamos hacemos uso de tipos básicos de datos, como enteros, decimales, caracteres, cadenas de caracteres, fechas. Pongo un ejemplo simple:<br />
<div>
<br /></div>
<div>
<div>
<span style="color: #38761d;"><b> </b>//definición de nombre y edad de la persona</span></div>
<div>
char *nombre;</div>
<div>
int edad;</div>
<div>
<span style="color: #38761d;"> //instanciación del nombre y la edad de la persona</span></div>
<div>
nombre = "Juan";</div>
<div>
edad = 21;</div>
</div>
<div>
<br /></div>
<div>
digamos que ahora queremos trabajar con la información de 2 personas:</div>
<div>
<br /></div>
<div>
<div>
<span style="color: #38761d;"> //definición de nombre y edad de las personas</span></div>
<div>
char *nombre1;</div>
<div>
int edad1;</div>
<div>
char *nombre2;</div>
<div>
int edad2;</div>
<div>
<span style="color: #38761d;"> //instanciación del nombre y la edad de las personas</span></div>
<div>
nombre1 = "Juan";</div>
<div>
edad1 = 21;</div>
<div>
nombre2 = "Pedro";</div>
<div>
edad2 = 25;</div>
</div>
<div>
<br /></div>
<div>
¿Qué pasaría si queremos trabajar con 100 personas? ¿Crearíamos 100 variables para el nombre y 100 variables para la edad?</div>
<div>
<br /></div>
<div>
Lo primero que se nos ocurre es que si son muchos elementos iguales podemos utilizar un Array, pero los elementos de un Array deben ser<u> todos del mismo tipo</u> por ejemplo char * para guardar un array de nombres o int para guardar un Array de edades. Así podríamos modificar nuestro programa para poder manejar la información de las 100 personas:</div>
<div>
<br /></div>
<div>
<span style="color: #38761d;">//instanciación de los Arrays de nombres y de edades</span></div>
<div>
char * nombres[100];</div>
<div>
int edades[100]; </div>
<div>
<br /></div>
<div>
Con esto tendríamos resuelto el manejo de la información de 100 personas con nombre y edad, pero qué pasaría si ahora además del nombre y la edad queremos saber: el apellido, la fecha de nacimiento, el número de identificación, el email, etc. ¿Tendríamos que crear un Array para cada dato?</div>
<div>
<br /></div>
<div>
La solución para esto son las estructuras (se llaman también registros o tuplas), son agrupaciones de tipos de datos para crear un nuevo tipo de dato definido por el programador, así con un único tipo de dato crearíamos un solo Array.</div>
<div>
<br /></div>
<div>
Para el ejemplo nuestro nuevo tipo de dato sería Persona y lo definiríamos así:</div>
<div>
<br /></div>
<div>
#include <stdio.h></div>
<div>
<div>
#include <stdlib.h></div>
<div>
#include <string.h></div>
<div>
<br /></div>
<div>
<span style="color: #38761d;">//nombre y edad quedan dentro de la estructura Persona</span></div>
<div>
</div>
<div>
<div>
typedef struct <b>Persona </b>{</div>
<div>
<div>
char * <b>nombre</b>;</div>
<div>
int <b>edad</b>;</div>
<div>
<span style="color: #38761d;"> //si quisiéramos agregar más información a la persona la agregaríamos aquí y no modificaríamos la definición del Array</span></div>
<div>
} Persona;</div>
</div>
<div>
<br /></div>
<div>
</div>
</div>
<div>
<br /></div>
<div>
int main(int argc, char *argv[])</div>
<div>
{</div>
<div>
<span style="color: #38761d;"> //Definimos un Array de 100 elementos de tipo Persona</span></div>
<div>
<span style="color: #38761d;"> //Persona es el tipo de variable</span></div>
<div>
<span style="color: #38761d;"> //listaPersonas es el nombre de la variable</span></div>
<div>
<b>Persona </b>listaPersonas[100];</div>
</div>
<div>
}</div>
<div>
<br /></div>
<div>
Las estructuras se utilizan normalmente en la programación estructurada y su concepto es similar al de las clases (programación orientada a objetos).</div>
MIPBhttp://www.blogger.com/profile/15144077089562468638noreply@blogger.com1