Fecha y hora actual: Miércoles 19 Dic 2018 00:53
Índice del Foro

Foros de programación informática, diseño gráfico y Web

En esta comunidad intentaremos dar soporte de programación a todos los niveles, desde principiantes a profesionales de la informática, desarrollo de programas, programación web y mucho más.

Programando desde 0: 38- Ejercicios de recursividad.

Responder al Tema Ir a página 1234Siguiente

Índice del Foro > Programación en general > Programando desde 0: 38- Ejercicios de recursividad.

Autor Mensaje
Kyshuo Ayame
Moderador Global


Registrado: 07 Ene 2011
Mensajes: 1033

Mensaje Publicado: Martes 29 Nov 2011 21:54

Título del mensaje: Programando desde 0: 38- Ejercicios de recursividad.

Responder citando

Ejercicios de Recursividad:

Hay de todo, algunos bien sencillos y otros muy difíciles.
Yo estaré siempre disponible para cualquier consulta que tengan.

Ejercicio 1: Fácil

Escriban una función booleana recursiva llamada SonIguales que reciba dos listas como parámetros y devuelva TURE si son iguales (mismos elementos en el mismo orden), o FALSE en caso contrario.

-------------------------------------------------------------------------------------
Ejercicio 2: Fácil

Escriban una función recursiva llamada ExisteElemento que verifique si un elemento x se encuentra en una lista L.

-------------------------------------------------------------------------------------
Ejercicio 3: Fácil

Escriban una función recursiva llamada Ocurrencia que cuente la cantidad de ocurrencias de un elemento x en una lista L.
Escriban una función recursiva llamada Suma que retorne la suma de los elementos de una lista de enteros L.

-------------------------------------------------------------------------------------
Ejercicio 4: Fácil

Escriba una función recursiva llamada Eliminar que elimine el elemento x de la lista L.
-------------------------------------------------------------------------------------
Ejercicio 5: Medio

Escriban una función recursiva llamada InsertarOrdenado que inserte en forma ordenada un elemento x en una lista ordenada L.

-------------------------------------------------------------------------------------
Ejercicio 6: Medio

Escriban una función recursiva llamada OrdenarLista que ordene una lista L.
-------------------------------------------------------------------------------------
Ejercicio 7: Medio

Escriban una función recursiva llamada Merge que, a partir de dos listas ordenadas L1 y L2, genere una lista ordenada L3, a través de un proceso de intercalación de elementos (merge).

-------------------------------------------------------------------------------------
Ejercicio 8: Medio

Escriba una función recursiva llamada Invertir que, dada una lista L, la invierta.

-------------------------------------------------------------------------------------
Ejercicio 9: Fácil

Escriba una función recursiva llamada Maximo que calcule el máximo de una lista de naturales L.

-------------------------------------------------------------------------------------
Ejercicio 10: Difícil

En una hilera de una calle con adoquines unos niños juegan a la rayuela. Para esto numeran los adoquines de la siguiente forma:



Los movimientos permitidos del juego son:

  • Al principio del juego los niños se ubican en el adoquín 0.
  • De un adoquín numerado i se puede saltar al adoquín numerado i+1.
  • De un adoquín numerado i se puede saltar al adoquín numerado i+2 (sin pasar por el adoquín i+1)
  • Por ejemplo, el número de caminos posibles para n=3 es 3 y son los siguientes: (0,1,2,3), (0,2,3) y (0,1,3).


Escriban una función recursiva llamada CaminosPosibles que calcule el número de caminos posibles para alcanzar un adoquín objetivo numerado con n (mayor que cero).

-------------------------------------------------------------------------------------
Ejercicio 11: Medio

Escriban una función recursiva llamada MCD que calcule el Máximo Común Divisor de 2 naturales a y b (con a >= b).

-------------------------------------------------------------------------------------
Ejercicio 12 – Problema de las Torres de Hanoi: Muy difícil

Escenario: existen tres cilindros verticales donde es posible insertar discos. En uno de los cilindros hay n discos todos de diferente tamaño, colocados en orden de tamaño con el más chico arriba. Los otros dos cilindros están vacíos.



El problema es pasar la torre de discos completa a otro de los cilindros usando como único movimiento elemental el cambio de un disco de un cilindro a otro cualquiera, sin que en ningún momento un disco vaya a colocarse encima de otro más chico que él.

Escriban el pseudocódigo de los procedimientos que consideren necesarios para imprimir las secuencias de movimientos elementales que resuelvan el problema de las torres de Hanoi, de cualquier tamaño. Los movimientos elementales son de la forma: MOVER DISCO x DEL cilindroY AL cilindroZ.

En este enlace pueden jugar con el problema de las Torres de Hanoi para visualizarlo mejor.

-------------------------------------------------------------------------------------
Notas acerca de los ejercicios 13 al 17:

Tengan en cuenta que para algunos de los siguientes ejercicios, es importante considerar:

1. Que puede ser necesario definir funciones auxiliares.
2. Que los parámetros de entrada o salida de las funciones pueden contener más de un elemento (ej: un parámetro que es una pareja).
3. Es parte de la resolución de los problemas decidir que parámetros es necesario considerar para la entrada o salida de la función.

Ejercicio 13: Dificil

Implementen en MODULA-2 y usando recursión el procedimiento del ejercicio 9 del apartado anterior de ejercicios de aplicación.
Dicho procedimiento recibe como parámetro una lista de naturales de tipo LNat y muestra todos los números de dicha lista, desde el último al primero, es decir, al revés. Ver el tipo LNat definido en el ejercicio 9 del apartado anterior de ejercicios de aplicación.

-------------------------------------------------------------------------------------
Ejercicio 14: Muy Dificil

Consideren la siguiente representación de polinomios mediante Listas de coeficientes:
P(x) = anxn + an-1x n-1 +…+ a1x1 + a0x0 se representa mediante la lista an, an-1, ... , a1, a0.
a. Escriban el pseudocódigo de una función recursiva que evalúe un polinomio usando la regla de Horner (P(x) = ((...((an* x) + an-1)x )+ ... + a1)x + a0).
b. Implementen la función de la parte a) en MODULA-2.

-------------------------------------------------------------------------------------
Ejercicio 15: Dificil

Escriban una función recursiva SumaC que dada una lista de Enteros positivos, indique la mínima cantidad de elementos consecutivos al final de la lista cuya suma sea mayor o igual que una determinada cantidad C, que se recibe como parámetro. Algunos ejemplos son:

    1, 2, 3, 4, 5, 6, 7 con C = 8 da 2 porque ( 6+7=13 > 8)
    7, 6, 5, 4, 3, 2, 1 con C = 8 da 4 porque (4+3+2+1=10 > 8)
    3, 6, 1, 7, 5, 2, 9 con C = 13 da 3 porque (5+2+9=16 > 13)


Nota: Si C supera la suma de todos los elementos de la lista deberá retornarse la cantidad de elementos que tiene la lista.
Para este ejercicio no se permite invertir la lista y luego resolverlo para los primeros elementos.

-------------------------------------------------------------------------------------
Ejercicio 16: Muy difícil

Consideren la siguiente representación de números binarios mediante Listas de dígitos:

    el número binario 1 (en base 10 es el 1) se representa mediante la lista [1]
    el número binario 10 (en base 10 es el 2) se representa mediante la lista [1,0]
    el número binario 110 (en base 10 es el 6) se representa mediante la lista [1,1,0]


Escriban un procedimiento recursivo Incremento que le sume 1 a un número binario, sin duplicar la lista. Algunos ejemplos de resultados son:

    Incremento([1]) = [1,0]
    Incremento([1,0])= [1,1]
    Incremento([1,1,0]) = [1,1,1]


Sugerencia: Considere como precondición de su procedimiento que la lista no puede ser vacía.

-------------------------------------------------------------------------------------
Ejercicio 17: Muy difícil

Una isla es una agrupación de celdas (al menos una) con valor 1, cada una de las cuales es adyacente horizontal y/o verticalmente a una celda del mismo grupo. Una isla está delimitada, horizontal y verticalmente, por celdas con valor 0 o por los límites (fronteras) del mapa.



Por ejemplo, en el mapa que se presenta de tamaño 5x10, hay 6 islas, las cuales están compuestas de las siguientes celdas:
  • Isla 1: (1,1) (1,2) (1,3) (2,1) (2,2)
  • Isla 2: (3,4)
  • Isla 3: (4,5)
  • Isla 4: (5,1) (5,2) (5,3)
  • Isla 5: (1,6) (1,7) (1,8) (1,9) (1,10) (2,10) (2,7) (3,7) (4,7) (5,7) (5,8)
  • Isla 6: (5,10)


Notar que (3,4) y (4,5) no forman una isla, sino que son dos islas distintas.

Escriban el pseudocódigo de un programa que, dado un mapa representado por una matriz de tamaño NxM de ceros y unos, donde 0 representa agua y 1 tierra, imprima las islas encontradas en el mismo.

Nota: Se pide que el programa imprima las celdas de cada isla del mapa siguiendo el formato del ejemplo. El orden de impresión entre las islas no es relevante, ni tampoco el orden en que se imprimen las celdas de cada isla.

-------------------------------------------------------------------------------------

Mucha suerte.

Volver arriba
Ver perfil del usuario Enviar mensaje privado
Sebastián Marcos
Usuario Inquieto


Registrado: 04 Oct 2011
Mensajes: 133

Mensaje Publicado: Sábado 17 Mar 2012 21:04

Título del mensaje: Re: Programando desde 0: 38- Ejercicios de recursividad.

Responder citando

Estimado Kyshuo, estoy empezando a realizar los ejercicios de recursividad, y pues, a mi entender, es como una nueva forma de pensar las cosas, un tanto más sutil, y también no hay duda que requiere muchísima práctica.

A continuación publico el código del ejercicio 4, que en realidad elimina el primer elemento de la lista igual a uno dado x (si es que lo contiene la lista).
TLista es un tipo lista que yo declaré con campos elemento y siguiente, así como TElem representa un tipo cualquiera para x.

Código:
PROCEDURE elimine(VAR l: TLista; x: TElem);
VAR
  aux: TLista;

BEGIN
  IF (l= NIL) THEN

  ELSIF (x= l^.elemento) THEN
    aux:= l^.siguiente;
    DISPOSE(l);
    l:=aux;
  ELSE
    elimine(l^.siguiente,x);
  END;

END elimine;



Como se ve, un caso base es que la lista que se pasa sea vacía. Supongo que el bloque del ELSIF también es otro caso base (¿O podemos decir que entra dentro del caso general?), o sea, cuando se llega a que se encuentra el elemento de la lista (si es que efectivamente está en la lista).
Por último, en el bloque del ELSE está el llamado recursivo.
Con la variable auxiliar aux (tipo puntero) "engancho" los punteros luego de eliminar el nodo correspondiente, no sé si esto está muy bien hecho.
Otra cosa "desprolija" es que no hay ninguna instrucción luego del primer IF, pero si la lista que se recibe es vacía no se hace nada, por eso lo planteé así.

Cualquier comentario, o mejora del procedimiento será bienvenido.
Saludos para todos.

Volver arriba
Ver perfil del usuario Enviar mensaje privado
Sebastián Marcos
Usuario Inquieto


Registrado: 04 Oct 2011
Mensajes: 133

Mensaje Publicado: Domingo 18 Mar 2012 19:08

Título del mensaje: Re: Programando desde 0: 38- Ejercicios de recursividad.

Responder citando

Viendo el código, está claro que no implementé una función, sino un procedimiento. De igual modo, suponiendo que fuera ésto lo que se necesitara, cualquier comentario o corrección será bienvenido.
Saludos a todos !!!

Volver arriba
Ver perfil del usuario Enviar mensaje privado
Kyshuo Ayame
Moderador Global


Registrado: 07 Ene 2011
Mensajes: 1033

Mensaje Publicado: Domingo 18 Mar 2012 20:09

Título del mensaje: Re: Programando desde 0: 38- Ejercicios de recursividad.

Responder citando

Aunque no era exacto lo que se pedía está bien hecho y le vas agarrando el hilo a esto de la recursividad, que bien sabemos no es para nada fácil de aprender...

Respecto a este comentario

Cita:
(...)Supongo que el bloque del ELSIF también es otro caso base...


Sí, es un caso base. Todo lo que se resuelve por sí mimo es caso base.

Excelente trabajo amigo Sebastián...

Volver arriba
Ver perfil del usuario Enviar mensaje privado
Sebastián Marcos
Usuario Inquieto


Registrado: 04 Oct 2011
Mensajes: 133

Mensaje Publicado: Lunes 19 Mar 2012 06:13

Título del mensaje: Re: Programando desde 0: 38- Ejercicios de recursividad.

Responder citando

Hola a todos !!!
Bueno, aquí publico mi código del ejercicio 2, cuyo enunciado es:
Escriban una función recursiva llamada ExisteElemento que verifique si un elemento x se encuentra en una lista L.
Como siempre digo, no sé si será la mejor solución, pero en principio funciona.

Código:
PROCEDURE ExisteElemento(L: TLista; x: TElem): BOOLEAN;
BEGIN
  IF (L= NIL) THEN
    RETURN FALSE;
  ELSIF (L^.elemento= x) THEN
    RETURN TRUE;
  ELSE
    RETURN ExisteElemento(L^.siguiente,x);
  END;
END ExisteElemento;


elemento (del tipo TElem) y siguiente son los campos de la lista del tipo TLista que se pasa como parámetro efectivo.
Como pueden ver paso por valor la lista ya que esta función no modifica a la misma, sólo nos devuelve información sobre ella.
Además los casos base son 1) Se pasa la lista vacía y 2) La lista tiene un sólo elemento (nodo).
Saludos a todos !!!

Volver arriba
Ver perfil del usuario Enviar mensaje privado
sr floyd
Usuario Activo


Registrado: 05 Sep 2011
Mensajes: 196

Mensaje Publicado: Lunes 01 Oct 2012 09:05

Título del mensaje: Re: Programando desde 0: 38- Ejercicios de recursividad.

Responder citando

Hola, esta es una respuesta al ejercicio numero 10, es una función recurrente llamada CantidadCaminos, corre dentro de un programa principal que pide el número de celda e imprime en pantalla la cantidad de posibles caminos; le he hecho pruebas y todas las ha superado jeje:
NOTA: se asume de acuerdo a la letra del ejercicio que el numero de la celda ingresada es N>0.

Código:
MODULE Caminos;

FROM STextIO IMPORT WriteString,SkipLine,WriteLn;
FROM SWholeIO IMPORT WriteCard,ReadCard;
FROM Storage IMPORT ALLOCATE;

VAR x,z: CARDINAL;


        PROCEDURE CantidadCaminos ( N: CARDINAL ): CARDINAL;

         TYPE
             Lista = POINTER TO NodoLista;

             NodoLista = RECORD
             elem: CARDINAL;
             sig: Lista;
             END;

             PROCEDURE CrearLista (N: CARDINAL ): Lista;
   
        VAR  Linked,aux: Lista;
             i: CARDINAL;
      
             BEGIN
   
        NEW (Linked);    Linked^.elem:=N;
        NEW (Linked^.sig);  aux:= Linked^.sig;
   
        FOR i:=N-1 TO 0 BY -1 DO
        aux^.elem:=i;
        NEW(aux^.sig);
        aux:=aux^.sig;
        END;
             aux:=NIL;
   
        RETURN Linked;
   
        END CrearLista;
   
    VAR
       aux,L : Lista;
       a,b: CARDINAL;
   
    BEGIN
   
    NEW(L);
    L:=CrearLista(N);
   
    IF L^.elem = 1 THEN     (* Casos bases *)
    RETURN 1;
    ELSIF  L^.elem=2 THEN
    RETURN 2;
   
    ELSE                    (* llamado recursivo *)
    a:= CantidadCaminos(L^.sig^.elem);
    NEW(aux); aux:= L^.sig^.sig;
    b:= CantidadCaminos( aux^.elem);
    RETURN
           a + b ;
    END;

         END CantidadCaminos;
   
       BEGIN

       WriteString('Digite un número de celda: '); ReadCard(x); SkipLine();
       WriteLn();
       z:= CantidadCaminos(x);
       WriteString('La cantidad de caminos es: '); WriteCard(z,1);

       END Caminos.   

Volver arriba
Ver perfil del usuario Enviar mensaje privado MSN Messenger
Kyshuo Ayame
Moderador Global


Registrado: 07 Ene 2011
Mensajes: 1033

Mensaje Publicado: Lunes 01 Oct 2012 16:35

Título del mensaje: Re: Programando desde 0: 38- Ejercicios de recursividad.

Responder citando

Amigo, no le he hecho pruebas exaustivas pero las que sí hice las pasó super bien. Un trabajo excelente, de verdad. ¿Se ha entendido entonces la recursividad? La verdad es genial que hayas podido resolver este ejercicio tú solo y sin preguntas.

Sigue así amigo, serás capaz de crear las aplicaciones que quieras.

Volver arriba
Ver perfil del usuario Enviar mensaje privado
sr floyd
Usuario Activo


Registrado: 05 Sep 2011
Mensajes: 196

Mensaje Publicado: Lunes 01 Oct 2012 22:20

Título del mensaje: Re: Programando desde 0: 38- Ejercicios de recursividad.

Responder citando

Infinitas Gracias por todo tu apoyo Kyshuo!!

Volver arriba
Ver perfil del usuario Enviar mensaje privado MSN Messenger
sr floyd
Usuario Activo


Registrado: 05 Sep 2011
Mensajes: 196

Mensaje Publicado: Viernes 05 Oct 2012 01:34

Título del mensaje: Re: Programando desde 0: 38- Ejercicios de recursividad.

Responder citando

Y bueno este es una respuesta al ejercicio 16. Es un programa ayudado por 3 procedimientos: LeerBinario, HastaUltimo y EscribirBinario(todos recursivos); básicamente LeerBinario lo implementé debido a que se considera la lectura en listas encadenadas del tipo inductivo al igual que la escritura; dicho procedimiento necesita saber hasta donde debe leer, pero como no conozco un procedure que lo permita tal como EOLN en Pascal pero para cardinales entonces se apoya de un cardinal (N) que le indica el número de digitos ingresados; Los digitos deben ingresarse con un espacio en blanco entre ellos porque cada uno es del tipo CARDINAL.
El papel que desempeña HastaUltimo (Función) es retornar la dirección del ultimo nodo, ésto es porque si el elemento almacenado allí es 0 se cambia por 1, de lo contrario se agrega otro sucecivo (UltimoNodo^.siguiente) y se almacena un 0.
El resultado es un programa como dije mas no un procedimiento como lo pide la letra, ¿qué habría que hacer para volverlo un procedimiento llamado desde un programa principal? que sea uno tal que haga un llamado por referencia a la variable que representa el primer nodo de la Lista, en este caso L1, la modificación sería sencilla...
Código:
MODULE Binario;

FROM STextIO IMPORT WriteString,WriteLn,SkipLine;
FROM Storage IMPORT ALLOCATE;
FROM SWholeIO IMPORT ReadCard,WriteCard;

TYPE

Lista= POINTER TO NodoLista;
NodoLista = RECORD
elem: CARDINAL;
sig: Lista;
END;

    PROCEDURE HastaUltimo(L:Lista): Lista;

      VAR aux: Lista;

      BEGIN
      IF L^.sig= NIL THEN
         RETURN L;
      ELSE
         NEW(aux);
    aux:=HastaUltimo(L^.sig);
    RETURN aux;
    END;
       END HastaUltimo;

    PROCEDURE LeerBinario ( VAR L: Lista; iterar:CARDINAL; tope: CARDINAL);

    BEGIN

    IF iterar=tope THEN
       L:=NIL;
    ELSE
       iterar:=iterar+1;
       ReadCard(L^.elem);
       NEW(L^.sig);
       LeerBinario( L^.sig,iterar,tope);
      END;
    END LeerBinario;


    PROCEDURE EscribirBinario (L: Lista);

     BEGIN
     IF L=NIL THEN
     WriteLn(); WriteLn(); WriteLn(); WriteLn(); WriteLn(); WriteLn();
     WriteString("                   Alan Turing era un genio!!!");

     ELSE
         WriteCard(L^.elem,1);
    EscribirBinario(L^.sig);
    END;
     END  EscribirBinario;


VAR
L1,aux: Lista;
N,cont: CARDINAL;

BEGIN
NEW(L1);
WriteString("Cuántos digitos tendrá el binario?: "); ReadCard(N); SkipLine;
WriteString("Binario de "); WriteCard(N,1); WriteString(" cifras: ");


 cont:=0;
 LeerBinario (L1,cont,N);
 SkipLine;

 aux:=HastaUltimo (L1);
 aux^.sig:=NIL;

IF aux^.elem = 0 THEN
   aux^.elem := 1;
ELSE
        NEW(aux^.sig);
        aux^.sig^.elem:= 0;
   aux^.sig^.sig:=NIL;

    END;

 WriteString("El resultado es: ");
 EscribirBinario(L1);

END Binario.

Volver arriba
Ver perfil del usuario Enviar mensaje privado MSN Messenger
sr floyd
Usuario Activo


Registrado: 05 Sep 2011
Mensajes: 196

Mensaje Publicado: Sábado 06 Oct 2012 09:07

Título del mensaje: Re: Programando desde 0: 38- Ejercicios de recursividad.

Responder citando

Y aqui mi ultima propuesta en este apartado de Recursividad. Se trata del ejercicio 15 que es un programa que cuenta con 7 Procedimientos (todos recursivos); el hecho de que no se pueda invertir la lista lo acompleja bastante y es eso precisamente la virtud del ejercicio; me alegra haber diseñado con mas elegancia la lectura de la lista (en comparación al ejercicio anterior), en este caso es el usuario quien decide cuando terminar de digitar los elementos de la misma. Al igual que el anterior ejercicio le he hecho el testing que se me ha ocurrido y ha respondido correctamente.
Código:
MODULE  SumaC;

FROM SWholeIO IMPORT ReadCard, WriteCard;
FROM STextIO  IMPORT WriteString, WriteLn, SkipLine, WriteChar,ReadChar;
FROM Storage IMPORT ALLOCATE;

 TYPE
 Lista = POINTER TO NodoLista;
 NodoLista = RECORD
 elem: CARDINAL;
 sig: Lista;
 END;

    PROCEDURE UltimaPosicion ( L:Lista): Lista;
              (* Devuelve dirección de ultimo nodo *)
      VAR aux: Lista;

      BEGIN
      IF L^.sig= NIL THEN
         RETURN L;
      ELSE
         NEW(aux);
         aux:=UltimaPosicion(L^.sig);
         RETURN aux;
        END;
      END UltimaPosicion;

     PROCEDURE NodoAnterior (L:Lista; cota: Lista): Lista;
          (*Dada la dirección de un nodo llamado cota devuelve el anterior*)
            (* USADO SOLO PARA LISTAS DE AL MENOS 2 NODOS*)
     VAR aux: Lista;

     BEGIN
     IF L^.sig = cota THEN
     RETURN L;

     ELSE
        NEW(aux);
   aux:= NodoAnterior(L^.sig,cota);
   RETURN aux;
   END;
     END  NodoAnterior;

    PROCEDURE SumaElems ( L:Lista ): CARDINAL;
       (* Devuelve la suma de los elementos de Lista desde la dirección L
                      hasta el último nodo*)
    VAR  card: CARDINAL;

    BEGIN
    IF L= NIL THEN
    RETURN 0;

    ELSIF L^.sig = NIL THEN
    RETURN L^.elem;

    ELSE
        card:= SumaElems (L^.sig);
   card:= L^.elem + card;
   RETURN card;
   END;
    END SumaElems;

    PROCEDURE ContarNodos (COTA: Lista ): CARDINAL;
    (* Cuenta los nodos de una lista a partir de la posición que indique cota*)

    VAR card: CARDINAL;

    BEGIN
    IF COTA = NIL THEN
    RETURN 0;
    ELSIF  COTA^.sig = NIL THEN
           RETURN 1;

    ELSE
        card:= ContarNodos (COTA^.sig);
   card:= card+1;
   RETURN card;
        END;
     END ContarNodos;

   PROCEDURE SUMAC (L1,L: Lista; C: CARDINAL): CARDINAL;
              (*NOTA: L1 representa el primer nodo de la lista*)
    VAR
    C2: CARDINAL;
    aux: Lista;

    BEGIN
    NEW(aux);
    aux:=NodoAnterior(L1,L);
    C2:= SumaElems(aux);
     IF C2 >= C THEN
        C2:= ContarNodos(aux);
   RETURN C2;
     ELSIF (C2<C) AND (aux=L1) THEN
     C2:= ContarNodos(L1);
     RETURN C2;

     ELSE
         C2:=SUMAC(L1,aux,C);
    RETURN C2;
    END;
     END SUMAC;

   PROCEDURE LeerLista (VAR L:Lista; index:CARDINAL);
              (* index es solo para ayudar al usuario a ver cuantos números
                 se ha ingresado a la lista *)
   VAR a: CHAR;
   aux: Lista;
   BEGIN
   IF L=NIL THEN
   WriteString("Ha finalizado de digitar la lista.");
   WriteLn();
   ELSE
   WriteString("Cardinal "); WriteCard(index,1);
   WriteString(": ");
   ReadCard(L^.elem);
   WriteLn;
   SkipLine;

   WriteString("Agregar Número? (S/N):");
   ReadChar(a); SkipLine();
     IF (a="N") OR (a="n") THEN
      aux:=NIL;
     ELSE
     NEW(L^.sig); aux:= L^.sig;
     END;
   index:=index+1;
   LeerLista(aux,index);
   END;
  END LeerLista;

  PROCEDURE  EscribirLista(L:Lista);
  BEGIN
  IF L=NIL THEN
  WriteChar(" ");
  ELSE
  WriteChar("[");
  WriteCard(L^.elem,1);
  WriteChar("]");
  EscribirLista(L^.sig);
  END;
  END EscribirLista;


VAR
L2,AUX: Lista;
suma,C3: CARDINAL;


BEGIN
C3:=1;
NEW(L2);
LeerLista(L2,C3);
WriteLn();
WriteString("La lista que ha digitado es: ");
EscribirLista(L2);
WriteLn();
WriteString("Digite C: ");
ReadCard(C3); SkipLine;

AUX:= UltimaPosicion(L2);

 IF AUX^.elem >= C3 THEN
  WriteLn();
  EscribirLista(L2); WriteString(" con C= "); WriteCard(C3,1);
  WriteString(" da "); WriteCard(1,1);
 ELSE
 suma:= SUMAC(L2,AUX,C3);
 WriteLn();
 EscribirLista(L2); WriteString(" con C= "); WriteCard(C3,1);
  WriteString(" da "); WriteCard(suma,1);
 END;


END SumaC.

En resumen han sido maravillosos los ejercicios!! Me quemaron las pestañas jajaja, pero intento siempre exprimir toda mi lógica...Magníficos, Muchas Gracias Kyshuo por la oportunidad!! Ok

Volver arriba
Ver perfil del usuario Enviar mensaje privado MSN Messenger
mrasd



Registrado: 26 Abr 2013
Mensajes: 8

Mensaje Publicado: Viernes 10 May 2013 01:24

Título del mensaje: Re: Programando desde 0: 38- Ejercicios de recursividad.

Responder citando

Les paso como me quedó mi Merge:

Código:

PROCEDURE Merge(l1,l2 : Lista): Lista;
VAR lista : Lista;
BEGIN
               IF (l1 = NIL) AND (l2 = NIL) THEN
                              RETURN NIL;
               ELSIF l1 = NIL THEN
                              RETURN l2;
               ELSIF l2 = NIL THEN
                              RETURN l1;
               ELSE
                              lista := Merge(l1^.sig,l2^.sig);
                              InsertarOrdenado(l1^.elem, lista);
                              InsertarOrdenado(l2^.elem, lista);
                              RETURN lista;
               END;
END Merge;

Volver arriba
Ver perfil del usuario Enviar mensaje privado
mrasd



Registrado: 26 Abr 2013
Mensajes: 8

Mensaje Publicado: Viernes 10 May 2013 19:24

Título del mensaje: Re: Programando desde 0: 38- Ejercicios de recursividad.

Responder citando

No se me ocurre como hacer el de invertir, ¿alguna idea?

Volver arriba
Ver perfil del usuario Enviar mensaje privado
Sebastián Marcos
Usuario Inquieto


Registrado: 04 Oct 2011
Mensajes: 133

Mensaje Publicado: Domingo 12 May 2013 20:40

Título del mensaje: Re: Programando desde 0: 38- Ejercicios de recursividad.

Responder citando

Hola!
Se me ocurre lo siguiente, en lenguaje natural sería:

Caso base: Si la lista es vacía la retorno

Caso inductivo: Retorno el resultado de insertar al final el primer elemento de la lista en la lista que se obtiene de invertir el resto de la misma.
Quedó medio entreverado jeje, sería esto:

Código:
RETURN InsertarAlFinal(Primero(l), Invertir(Resto(l)));


o lo que es lo mismo:

Código:
RETURN InsertarAlFinal(l^.elem, Invertir(l^.sig));


Intenta implementar las operaciones InsertarAlFinal con el encabezado:
Código:
InsertarAlFinal(elem: Elemento, l: Lista)
(* Inserta "elem" al final de la lista "l" *)


e implementa Invertir, aunque de esta última ya te dí una opción para el llamado recursivo.

Date cuenta que la lista devuelta "se construye" en la vuelta de la recursión, como pasa muchas veces en este tema. Además la lista que se devuelve es distinta a la original.

Cualquier cosa nos comentas.
Saludos.

Volver arriba
Ver perfil del usuario Enviar mensaje privado
xRoki
Usuario Inquieto


Registrado: 22 Ago 2013
Mensajes: 71

Mensaje Publicado: Lunes 07 Oct 2013 02:36

Título del mensaje: Re: Programando desde 0: 38- Ejercicios de recursividad.

Responder citando

EJERCICIO 1

Código:

PROCEDURE SonIguales(lista1 , lista2 : Tipos): BOOLEAN;


BEGIN
 IF (lista1=NIL) AND (lista2=NIL) THEN
       RETURN TRUE;
     END;

IF lista1^.numero=lista2^.numero THEN

   IF SonIguales(lista1^.siguiente,lista2^.siguiente) THEN

    RETURN TRUE;

    ELSE RETURN FALSE;

   END;

ELSIF lista1^.numero<>lista2^.numero THEN

   RETURN FALSE;


END;




END SonIguales;





EJERCICIO 2

Código:
PROCEDURE ExisteElemento(x : INTEGER; lista : Tipos): BOOLEAN;
BEGIN

IF lista=NIL THEN
RETURN FALSE;
END;



IF lista<>NIL THEN

IF lista^.numero<>x THEN

IF ExisteElemento(x,lista^.siguiente) THEN
RETURN TRUE

ELSE
RETURN FALSE;
END;

ELSIF lista^.numero=x THEN
RETURN TRUE;

END;

END;

END ExisteElemento;


EJERCICIO 3

Código:
PROCEDURE Ocurrencia(x : INTEGER ; l : Tipos):  INTEGER;
VAR


BEGIN



IF l<>NIL THEN

IF l^.numero=x THEN
RETURN Ocurrencia(x,l^.siguiente)+1;

ELSIF l^.numero<>x THEN
RETURN Ocurrencia(x,l^.siguiente);

END;

ELSE

RETURN 0;
END;

END Ocurrencia;


Código:
PROCEDURE Suma(l:Tipos): INTEGER;
VAR
a: INTEGER;
BEGIN

IF l<>NIL THEN

a:=l^.numero;

RETURN Suma(l^.siguiente)+a;




ELSE RETURN 0;


END;


END Suma;


EJERCICIO 4
Este Ejericico me dio una leccion de que si te enredaste no importa lo qhayas echo xD borralo .. porque al principio todo mal no me salio , y tard emucho xD luego fui atomar agua , borre lo q tenia y en unos segundos lo hice. xD jajaja

Código:
PROCEDURE Eliminar(x :INTEGER; VAR  l : Tipos);
VAR
a: INTEGER;
BEGIN



   IF (l^.siguiente=NIL) AND (x=l^.numero) THEN
   l:=NIL;

   ELSIF (x=l^.numero) AND (l^.siguiente<>NIL) THEN

   a:=l^.numero;
   l^.numero:=l^.siguiente^.numero;
   l^.siguiente^.numero:=a;
  Eliminar(x,l^.siguiente);

   ELSIF (x<>l^.numero) THEN
   Eliminar(x,l^.siguiente);



   END;




END Eliminar;




OK TERMINE LA PARTE FACIL XD

Volver arriba
Ver perfil del usuario Enviar mensaje privado
xRoki
Usuario Inquieto


Registrado: 22 Ago 2013
Mensajes: 71

Mensaje Publicado: Lunes 07 Oct 2013 03:35

Título del mensaje: Re: Programando desde 0: 38- Ejercicios de recursividad.

Responder citando

EJERCICIO 5

xD sera la ultima qhaga hoy xD manaña tengo clases Triste

Código:
PROCEDURE InsertarOrdenado(VAR x :INTEGER;  VAR l: Tipos);
VAR
a: INTEGER;
BEGIN

IF l<>NIL  THEN
IF x<l^.numero THEN

a:=l^.numero;
l^.numero:=x;
x:=a;


InsertarOrdenado(x,l^.siguiente);

ELSIF x>l^.numero THEN

InsertarOrdenado(x,l^.siguiente);

ELSIF x=l^.numero THEN

InsertarOrdenado(x,l^.siguiente);
END;
END;

 IF l=NIL THEN

NEW(l);
l^.numero:=x;

 END;


END InsertarOrdenado;

Volver arriba
Ver perfil del usuario Enviar mensaje privado
Responder al Tema Ir a página 1234Siguiente
Mostrar mensajes anteriores:   
Ir a:  
Todas las horas están en GMT + 2 Horas

Temas relacionados

Tema Autor Foros Respuestas Publicado
El foro no contiene ningún mensaje nuevo

hola!! los saludo desde argentina

mery Preséntate a la comunidad 2 Jueves 13 Dic 2018 17:28 Ver último mensaje
El foro no contiene ningún mensaje nuevo

Llamada a web service desde form

mrrobot2 Programación Web en general 1 Martes 14 Nov 2017 00:50 Ver último mensaje
El foro no contiene ningún mensaje nuevo

[Duda] Ejercicios Archivo Binario - En C

Pedrolo C, C#, Visual C++ 1 Viernes 03 Nov 2017 04:17 Ver último mensaje
El foro no contiene ningún mensaje nuevo

Crear web desde 0

javitc Programación Web en general 11 Sábado 30 Sep 2017 21:23 Ver último mensaje
El foro no contiene ningún mensaje nuevo

Nuevo desde México!

MarioC Preséntate a la comunidad 1 Viernes 30 Dic 2016 19:39 Ver último mensaje
Panel de Control
No puede crear mensajes, No puede responder temas, No puede editar sus mensajes, No puede borrar sus mensajes, No puede votar en encuestas,