Palindromos
Upcoming SlideShare
Loading in...5
×

Like this? Share it with your network

Share
  • Full Name Full Name Comment goes here.
    Are you sure you want to
    Your message goes here
    Be the first to comment
No Downloads

Views

Total Views
12,377
On Slideshare
8,672
From Embeds
3,705
Number of Embeds
21

Actions

Shares
Downloads
78
Comments
0
Likes
1

Embeds 3,705

http://danielaaguilarguerra.blogspot.com 2,191
http://danielaaguilarguerra.blogspot.mx 1,202
http://danielaaguilarguerra.blogspot.com.es 101
http://danielaaguilarguerra.blogspot.com.ar 100
http://salomon-karr.blogspot.com 29
http://www.slideshare.net 22
http://gaby-agata.blogspot.com 17
http://danielaaguilarguerra.blogspot.com.br 10
http://danielaaguilarguerra.blogspot.it 7
http://gaby-agata.blogspot.mx 6
http://salomon-karr.blogspot.mx 4
http://danielaaguilarguerra.blogspot.de 4
http://www.danielaaguilarguerra.blogspot.com 2
http://danielaaguilarguerra.blogspot.co.uk 2
http://www.google.com.mx 2
http://www.google.com.ar 1
http://www.google.com.ec 1
http://gaby-agata.blogspot.co.uk 1
http://gaby-agata.blogspot.com.ar 1
http://danielaaguilarguerra.blogspot.in 1
http://danielaaguilarguerra.blogspot.pt 1

Report content

Flagged as inappropriate Flag as inappropriate
Flag as inappropriate

Select your reason for flagging this presentation as inappropriate.

Cancel
    No notes for slide

Transcript

  • 1.
    • Gabriela Alemán García Daniela Aguilar Guerra Salomon Karr Hector Tinajero
  • 2.
    • En la verificación de palíndromos usando la iteración tenemos la opción de verificar mas de un palíndromo.
    • En cambio con la recursión se llama así misma la función para leer el primer texto y compararlo con su lectura al revés y así define si es o no un palíndromo.
    • Los primeros palíndromos se le atribuyen al filosofo griego Sócrates (III a.c).
  • 3.
    • En la verificación de palíndromos. La relación del tamaño del problema y su tiempo de ejecución es polinómica por tal motivo nuestro problema es del tipo P, la maquina determinista lo puede resolver en tiempo real y razonable.
    • La clase de complejidad P es el conjunto de los problemas de decisión que pueden ser resueltos en una máquina determinista en tiempo poli nómico, lo que corresponde intuitivamente a problemas que pueden ser resueltos aún en el peor de sus casos.
    • Existe una solución en tiempo P para todos los problemas de NP-completo, SOLO si se llega a encontrar una solución en tiempo P para algún miembro del conjunto (cualquiera de los problemas de Np-Hard)
  • 4.
    • La declaración f(x)=O(g(x)) donde se relaciona el tiempo de ejecución con el espacio de memoria utilizado, de allí se le dan los valores en segundos, pero como se extiende, tendemos a utilizar la función logarítmica para determinar el comportamiento congresito al tiempo y espacio en la solución de nuestro problema.
  • 5.
    • #include <stdio.h> //incluimos librerias
    • #include <string.h>
    • char inverso(char *arreglo); //declaramos funcion que va a realizar la inversa
    • int main() { //iniciamos funcion principal
    • int opcion;
    • char arreglo[255]; //declaramos el arreglo de 255 caracteres, el arreglo es una cadena de caracteres.
    • printf(&quot; PROGRAMA VERIFICADOR DE PALINDROMOS &quot;);
    • do{
    • printf(&quot;Ingresa el texto que deseas verificar &quot;); //imprime mensaje al usuario
    • gets(arreglo); //utilizamos funcion gets para que pueda leer toda la cadena
    • inverso(arreglo); //manda llamar a la funcion del inverso y se lleva lo que escribimos en arreglo
    • do{
    • printf(&quot; Desea verificar otro texto 1.-Si 2.-No &quot;);
    • scanf(&quot;%d&quot;,opcion);
    • }while(opcion<1 || opcion>2);
    • }while(opcion==1);
    • return 0;
    • }
    • char inverso(char *arreglo) { // inicia funcion inverso
    • int conta, longitud; //declaramos contadores y la variable que tendra el numero de caracteres
    • longitud=strlen(arreglo); //ulilizamos la funcion strlen para saber la longitud de la cadena
    • conta=longitud; //contador que va a hacer igual a longitud de la cadena
    • while(conta >= 0){ //mientras contador sea mayor o igual que 0
    • printf(&quot;%c&quot;, arreglo[conta]); //imprima el caracter del ultimo al primero
    • conta--; //va a ir en decremento
    • }
    • return 0;
    • }
    INICIO Texto1 Inverso Texto1 Texto 2 Texto 1 = Texto 2 Es palíndromo No es palíndromo Analizar otro texto? FIN
  • 6.
    • #include <stdio.h>
    • #include <stdlib.h>
    • #include <string.h>
    •   int palindromo(char * principio, char * final){
    •   if ((final - principio) < 2)
    • return 1;
    • else
    • if( (*principio) != (*final) )
    • return 0;
    • else
    • return palindromo(++principio, --final);
    • }
    • main()
    • {
    • char cadena[20];
    • char * final;
    • int cuenta;
    •  
    • system(&quot;cls&quot;);
    •  
    • printf(&quot;¿Cual es tu Cadena de caracteres? &quot;);
    • gets(cadena);
    •  
    • final=cadena + strlen(cadena) - 1;
    •  
    • if (palindromo(cadena, final))
    • printf(&quot;Es palindroma &quot;);
    • else
    • printf(&quot;No es palindroma &quot;);
    •  
    • system(&quot;pause&quot;);
    • printf (&quot;Fin de la ejecucion. &quot;);
    • return 0;
    • }
  • 7.
    • ITERATIVO
    Palabra “abba” int i = 0, j = 0; // Se declaran las variables &quot;i&quot; y &quot;j&quot; con valor de 0 char cadena[50], cadena_inversa[50]; // Se declaran las variables &quot;cadena&quot; y &quot;cadena_inversa&quot; con una dimension de 50 espacios gets(cadena); // Se obtiene una palabra por parte del usuario // Mientras el valor de cadena no sea igual a 0 se sumará un valor a la variable &quot;i&quot;, el valor &quot;0&quot; es devuelto cuando se llega // a una posición de la variable no declarada, pues esta es una forma de saber el número de carácteres de una variable sin // necesidad de utilizar la libreria string.h ni la función &quot;strlen()&quot; while(cadena[i] != 0) {i = i + 1;} i = i - 1; // Se resta un valor a la variable i, pues con el método anterior queda con 1 valor más del número de carácteres // Mientras la variable &quot;i&quot; no sea igual a 0 (El valor tiene que ser positivo por el bucle anterior) se estará asignando un char // a la variable &quot;cadena_inversa&quot;, un ejemplo, tomamos la palabra &quot;abba&quot;, i = 4 y j = 0 al principio, entonces se asigna el char // de la posicion 4 de &quot;cadena&quot; a &quot;cadena_inversa&quot;, seguidamente se suma un valor a &quot;j&quot; y se resta un valor a &quot;i&quot;, con lo que // queda j = 1 e i = 3, con este método se estan copiando los carácteres de &quot;cadena&quot; a &quot;cadena_inversa&quot; de manera &quot;inversa&quot; // el bucle se deja de ejecutar cuando i es igual a 0, osea cuando se han recorrido todos los carácteres de la variable &quot;cadena&quot; while(i != 0) {cadena_inversa[j] = cadena[i]; j = j + 1; i = i - 1;} // Se asigna el valor 0 a cadena_inversa en la posición &quot;j&quot; que viendo el ejemplo anterior quedaría en la posición 5, el valor // 0 se asigna solamente para definir el final de la cadena cadena_inversa[j] = 0; // Si el valor original de &quot;cadena&quot; es igual a &quot;cadena_inversa&quot; se imprime mensaje de &quot;Es palindromo&quot;, sino se imprime // el mensaje contrario if (*cadena == *cadena_inversa) {printf(&quot;Es palindromo &quot;);} else {printf(&quot;No es palindromo &quot;);}
  • 8.
    • RECURSIVO
    ‘ ANITA LAVA LA TINA’ Verificar si la palabra ( anita lava la tina ) es palíndromo //el programa le pide el texto al usuario _anita lava la tina después el programa le da al usuario el texto invertido (al revés) * anit al aval atina _ //luego se hace la pregunta que si la salida del programa, es igual a la que el usuario le dio al principio If anita lava la tina = anit al aval atina printf(‘Es palíndromo’) else printf(‘No es palíndromo’) Fin
  • 9.
    • RECURSIVIDAD
    • Se debe usar cuando realmente se necesite y cuando el problema no se puede resolver fácilmente con la iteración.
    •  
    • Se usan cuando no se conoce un método para encontrar la solución de forma exacta.
    • Cuando el numero de iteraciones es poco.
    • ITERATIVIDAD
  • 10.
    • VENTAJAS
    • DESVENTAJAS
    • Soluciones simples y claras.
    • Eficientes
    • Soluciones a problemas complejos.
    • Sobrecarga relacionadas con las llamadas a los subalgoritmos, (una simple llamada puede generar un gran numero de llamadas recursivas).
    • La claridad no recompensa la sobrecarga.
  • 11.
    • VENTAJAS
    • DESVENTAJAS
    • La programación es simple.
    • Es fácilmente aplicable cuando los coeficientes son no lineales.
    • No se puede aplicar a cada sistema .
  • 12.
    • Nosotros como equipo concluimos en que antes buscar una solución para cierto problema, primero se tiene que analizar todas las posibles vías hacia esta solución, buscando la manera mas eficiente y descartando las que nos compliquen llegar exitosamente a nuestro destino.
  • 13.
    • www.lcc.uma.es/~lopez/modular/recursion/transp_recursion.pdf
    • Fundamentos de la programación. Joyanes Aguilar, Mc Graw Hill, 1988.
    • www.mty.itesm.mx/etie/deptos/m/ma95-843/.../l843-13.pdf
    • http://students.kennesaw.edu/~kjj6794/class/math3261/Iteration%20Methods.ppt