/*
Nombre: Codigo Fibonacci
Autor: Julian Rodriguez
Tema: Recursividad
Fecha: 27/Junio/2008
*/
#include <iostream>
using namespace std;

int fibonacci(int n); // Funcion Recursiva
int main()
{
int n, resultado; // Variables

cout << "Escribe el numero de posicion: ";
cin >> n;

resultado = fibonacci(n);
cout << endl << "[+]Posicion: " << n << " Valor: " << resultado << endl;;

return EXIT_SUCCESS;
}

int fibonacci(int n)
{
cout << "[-]Procesando: Fib(" << n << ")" << endl;
if( n < 3 )
{
return (1);
}
else
{
cout << "Fib(" << n-2 << ") - " << "Fib(" << n-1 << ")" << endl;
return ( fibonacci(n-2) + fibonacci(n-1) );
}
}

/*
Nombre: Codigo Fibonacci
Autor: Julian Rodriguez
Tema: Recursividad
Fecha: 27/Junio/2008
*/
#include <iostream>
using namespace std;

int funcion(int n, int p);
int main()
{
int resultado, n, p;

cout << "Escribe un numero: ";
cin >> n;
cout << "Escribe la potencia: ";
cin >> p;

resultado = funcion(n, p);
cout << "Numero " << n << " elevado a la " << p << "; Resultado = " << resultado;
cout << endl;
getchar();

return EXIT_SUCCESS;
}

int funcion(int n, int p)
{
if(p == 1)
{
return n;
}
else
{
return ( n * funcion(n, p-1) );
}
}

Incluye el código fuente y una referencia al código fuente de un experimento de "varices" tambien muy padre visualmente.

En cierto sentido, un árbol es lo más opuesto posible a un bucle (dado que explícitamente prohíbe los ciclos); pero me gusta esta estructura porque tiene una definición recursiva muy sencilla.

La idea del proyecto es que cada nodo del árbol define una historia distinta, que se puede extender agregando continuaciones a gusto (para mantener un poco acotada la cosa, puse un límite de 12 continuaciones posibles por nodo; pero creo que es más que suficiente).

No es una idea nueva; todos recordarán la famosa serie de libros Elige tu propia aventura (aunque eran estáticos y no se podían extender), y actualmente hay muchos proyectos por el estilo en internet; pero no muchos en español.

Espero que les guste el proyecto y agreguen sus propios capítulos; puede que dentro de un tiempo publique en forma lineal las ramas más graciosas o bellas.

..."Por cierto sigue con la estupidez de las frases “cut & paste” que encuentra en sus largas horas de ocio no creativo en la web."...
Anonymous

(gracias Silta por el link)

fibonacci(10,0,1);
getch();
}

void fibonacci(int n,int f,int aux)
{
cout<<"\n"<<f;
//    b=c;
//    c=f;
//    f=b+c;
if(n>1)

{
fibonacci((n-1),(f+aux),(f));
}

}

OTRA SOLUCION

//Fibbonacci con recursividad
#include<iostream.h>
#include<conio.h>
void fibonacci(int n);
int f=0,b=1,c=1;
void main()
{
clrscr();
int a;
cout<<"INGRESE NUMERO: ";
cin>>a;
fibonacci(a);
//    cout<<n<<"\t";
getch();
}

void fibonacci(int n)
{
cout<<"\n"<<f;
b=c;
c=f;
f=b+c;
if(n>1)

{
n--;
fibonacci(n);
}

}
OTRA SOLUCION

//Fibbonacci con recursividad
#include<iostream.h>
#include<conio.h>
void fibonacci(int n,int b,int c, int  f);
//int f=0,b=1,c=1;
void main()
{
clrscr();
int a;
//    cout<<"INGRESE NUMERO: ";
//    cin>>a;
fibonacci(18,1,1,0)
;
//    cout<<n<<"\t";
getch();
}

void fibonacci(int n,int b, int c, int f)
{
cout<<"\n"<<f;
//    b=c;
//    c=f;
//    f=b+c;
if(n>1)

{
fibonacci((n-1),c,f,(f+c));
}

}

void  func1(int n);

int x,f=0,b=1,c=1;

void  main()
{
        clrscr();
        cout<<"\t Ingrese un Numero:  ";
        cin>>x;
        cout<<"\n\n";
        func1(c);
        getch();
}

void func1(int n)
{

     cout<<"\t\t"<<f<<"\n\n";
     b=c;
     c=f;
     f=b+c;
     if(x>1)
    {
         x--;
         func1(n);
    }

}

Un algoritmo es recursivo cuando se llama de una función a la misma función, pero si esto fuera todo se llamaría a la misma función hasta que se agote la memoria en ejecución, por lo tanto debe controlarse mediante una condición de salida, que permita controlar las veces que debe repetirse la función.

Un ejemplo de un algoritmo recursivo, este permite presentar la serie de fibonacci de n números, el algoritmo cumple con la funcion pero no es factible, no es recursivo en una forma total.

------------------------------------------------------
#include<iostream.h>
#include<conio.h>

#include<dos.h>
void func1(int n);
int f=0,b=1,c=1;
void main()
{
clrscr();
int n;
//cout<<"INGRESE NUMERO:";
// cin>>n;
func1(5);

getch();
}

void func1(int n)
{
cout<<"\t\t"<<f<<"\n\n";
b=c;
c=f;
f=b+c;
if(n>1)
{
n--;
func1(n);

}

}

Estos dos algoritmos permiten presentar la misma serie, los algoritmos son optimos.

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

//Serie de fibonacci con recursividad
#include<iostream.h>
#include<conio.h>

#include<dos.h>
void func1(int n,int b,int c,int f);
void main()
{
clrscr();
int n;
//cout<<"INGRESE NUMERO:";
// cin>>n;
func1(5,1,1,0);

getch();
}

void func1(int n,int b,int c,int f)
{
cout<<f;
if(n>1)
{
func1((n-1),c,f,(f+c));
}
}

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

En este ejemplo se utiliza solo dos variables enteras (aux, f)

//Serie de fibonacci con recursividad y dos variables
#include<iostream.h>
#include<conio.h>
#include<dos.h>

void func1(int n,int f,int aux);

void main()
{
clrscr();
int n;
// cout<<"INGRESE NUMERO:";
// cin>>n;
func1(5,0,1);

getch();
}

void func1(int n,int f,int aux)
{
cout<<f;

if(n>1)
{

func1((n-1),(f+aux),f);

}
}

void func1(int n,int b,int c,int f);
void  main()
{
  clrscr();
  int n;
  func1(5,1,1,0);

 getch();
}

void func1(int n,int b,int c,int f)
{
 cout<<f;
 if(n>1)
 {
  func1((n-1),c,f,(f+c));
        }
}

void func1(int n,int f,int aux);

void  main()
{
 clrscr();
 int n;
     func1(5,0,1);

 getch();
}

void func1(int n,int f,int aux)
{
 cout<<f;

 if(n>1)
 {

  func1((n-1),(f+aux),f);

 }
}

//Fibbonacci con recursividad
#include<iostream.h>
#include<conio.h>
int fibonacci(int n);
void main()
{
 clrscr();
 int n,f;
 cout<<"INGRESE NUMERO: ";
 cin>>n;
 fibonacci(n);
 cout<<n<<"\n";
 getch();
}

int fibonacci(int n)
{
    if(n==0)
    {
       return 0;
    }
    else
    {
 if(n==1)
 {
     return 1;
 }
 else
 {
    return fibonacci(n-1) + fibonacci(n-2);
 }
    }
}

LA SIGUIENTE CODIFICACION ES OTRA SOLUCION

//Fibbonacci con recursividad
#include<iostream.h>
#include<conio.h>
void fibonacci(int n);
int f=0,b=1,c=1;
void main()
{
 clrscr();
 int a;
 cout<<"INGRESE NUMERO: ";
 cin>>a;
 fibonacci(a);
       // cout<<n<<"\t";
 getch();
}

void fibonacci(int n)
{
 cout<<"\n"<<f;
 b=c;
 c=f;
 f=b+c;
 if(n>1)

 {
   n--;
   fibonacci(n);
 }

}
ESTA ES OTRA DE UNA DE LAS SOLUCIONES

//Fibbonacci con recursividad
#include<iostream.h>
#include<conio.h>
void fibonacci(int n,int f,int aux);
//int f=0,b=1,c=1;
void main()
{
 clrscr();

 fibonacci(10,0,1);
 getch();
}

void fibonacci(int n,int f,int aux)
{
 cout<<"\n"<<f;
       // b=c;
       // c=f;
      // f=b+c;
 if(n>1)

 {
   fibonacci((n-1),(f+aux),(f));
 }

}
 

:::::ESPERO QUE  ESTAS SOLUCIONES DE LA SERIE DE FIBONACCI SEA DE UNA GRAN AYUDA::::

//programa para presentar los numeros fibonaci  con
//recursividad  esta es una solucion

#include<iostream.h>
#include<conio.h>
void  fibo( int n,int b,int c, int f);
void main()

{

 clrscr();
 fibo(5,1,1,0);
 getch();
}
void  fibo (int n,int b,int c, int f)
{
 cout<<f<<"\n";
 if(n>1)
 {

  fibo((n-1),c,b,(f+c));

 }

}

//programa que permita la serie de los n numeros de la  fibonaci esta vien
// con recursividad
#include<iostream.h>
#include<conio.h>
//prototipo
void  funcion1( int n);
//variables globales
int b=1,c=1,f=0;
//funcion principal
void main()
{
 int a;
 clrscr();
 cout<<"ingrese los n numeros e la fibonaci";
 cin>>a;
 funcion1(a);
 getch();
}
void funcion1(int n)
{
 cout<<f;
 b=c;
 c=f;
 f=b+c;
 if(n>1)
 {
  n--;
  funcion1(n);
 }
}
//ejercicio que presenta la serie del fibonaci de n numeros
// con recursividad
//esta es otra solucion
#include<iostream.h>
#include<conio.h>
void  fibo( int n,int f, int aux);
void main()

{

 clrscr();
 fibo(5,0,1);
 getch();
}
void  fibo (int n,int f,int aux)
{
 cout<<f<<"\n";
 if(n>1)
 {

       fibo((n-1),(f+aux),(f));
 }

}

Traduzco la descripción:

«Gridcosm es un proyecto de arte colaborativo, en el cual artistas de todo el mundo contribuyen con imágenes para componer una serie de grillas gráficas. Cada nivel de Gridcosm está hecho de nueve imágenes cuadradas, dispuestas en una grilla de 3x3. La imagen central es una versión de un tercio del tamaño del nivel anterior. Los artistas agregan imágenes alrededor de la imagen central hasta que se completa la grilla de 3x3, y luego el nivel se reduce y se convierte en la semilla del próximo nivel. Este proceso crea un túnel de imágenes en expansión, siendo cada nuevo nivel el resultado directo del nivel anterior, el cual es resultado del nivel anterior, y así ad infinitum.»

Es un impresionante trabajo. Produce un efecto (creo que intencionalmente) surreal, y más si se lo navega con esta herramienta flash, que permite hacer un zoom casi continuo entre niveles.

En mi anterior entrada dije que iba a intentar hablar de las listas y las tuplas. Estoy vago, así que voy a hablar sólo de las primeras.

Las listas en Erlang se escriben entre corchetes y separadas por comas. Así de sencillo.

1> [1,2,3,4].
[1,2,3,4]

O así de complicado, como se quiera ver. Los miembros pueden ser escalares, otras listas, tuplas etcétera.

2> [atomo,[1,2],3].
[atomo,[1,2],3]

Podemos asignárselas a variables, pasárselas como parámetros a funciones, incluir el resultado de funciones en ellas...

3> Lista=[datos,[1,5,max:max(1,5)]].
[datos,[1,5,5]]

La función max:max/2 la definimos en la anterior entrada.

¿Cómo podemos escribir una función que procese una lista? Buen, hay que saber dos cosas más sobre las listas. La primera, que una lista vacía se identifica con un par de corchetes, "[]". La segunda es que una lista se puede descomponer, salvo que sea vacía, en dos elementos: Cabeza y Cola.

La "cabeza" es el primer elemento, la "cola" es la lista formada por el resto de elementos de la lista. Si la lista sólo tiene un elemento, la cola será una lista vacía.

Para ilustrarlo, no me voy a salir del shell, todavía, y voy a utilizar una funcionalidad llamada "pattern matching" (nunca he sabido cómo traducir eso). Esta funcionalidad se traduce en una gran flexibilidad a la hora de hacer asignaciones.

Antes de mostrar lo de la cabeza y la cola, voy a mostrar un par de ejemplos del "pattern matching" ese, un poco limitado por no haber tuplas:

4> [A,B]=[1,2].
[1,2]
5> A.
1
6> B.
2
7> [C,[D,E]]=[3,[A,[1,2,3]]].
[3,[1,[1,2,3]]]
8> C.
3
9> D.
1
10> E.
[1,2,3]

Eso sí, si lo de la derecha y lo de la izquierda no se corresponden, tendremos un errory no conseguiremos nada:

11> [F,G,H]=[1,[2,3]].
** exception error: no match of right hand side value [1,[2,3]]
12> F.
* 1: variable 'F' is unbound

A la hora de dividir una lista en cabeza y cola, empleamos el carácter de tubería, "|". Así, toda lista es equivalente a [Cabeza|Cola]:

13> [Cabeza|Cola]=[1,2,3,4].
[1,2,3,4]
14> Cabeza.
1
15> Cola.
[2,3,4]

Como dije antes, la cola puede ser una lista vacía y la lista vacía no se puede descomponer:

16> [Cabeza2|Cola2]=[unsoloelemento].
[unsoloelemento]
17> Cabeza2.
unsoloelemento
18> Cola2.
[]
19> [Cabeza3|Cola3]=Cola2.
** exception error: no match of right hand side value []

Esta construcción también puede utilizarse para crear listas:

20> [5|Cola].
[5,2,3,4]

Sabiendo esto, no debería ser muy difícil adivinar cómo procesar listas en nuestras funciones. Tomemos este código:

Como he hecho con anterioridad, voy a analizar el código:

lista([Cabeza|Cola]) ->

Esta primera definición de la función imprime:lista/1 es la que hace el trabajo. Cuando recibe una lista, almacena el primer elemento de la misma en la variable Cabeza y el resto de la lista, como una nueva lista, en Cola. Cualquier lista no vacía es válida, ya tenga un elemento, en cuyo caso Cola sería una lista vacía, o un millón, en cuyo caso Cola tendría 999.999 elementos.

io:format("~w~n", [Cabeza])

La función io:format/2 es una de las funciones estándar de Erlang. Ya hablé por encima de ella en mi primera entrada, pero voy a profundizar un poco.

Toma dos parámetros: una cadena y una lista (esto no es del todo preciso como explicaré más adelante). La cadena indica el formato con el que se quieren imprimir los miembros de la lista. Sí, se parece terriblemente a printf.

En nuestro caso, la cadena es "~w~n". En lugar del símbolo de tanto por ciento "%" utilizando en printf, la función io:format/2 de Erlang utiliza la tilde de la eñe, "~". El primer código, "~w", quiere decir "imprimir el dato con la sintáxis estándar"; es válido para cualquier construcción en Erlang. El segundo, "~n", indica que se debe imprimir un salto de línea. Por supuesto, podríamos haber incluído literales. La documentación completa de la función está aquí.

El caso es que, con esta función, lo que estamos haciendo es imprimir Cabeza con la sintáxis estándar adecuada en una línea.

, (coma)

Otra novedad, la coma. Hasta ahora la habíamos visto separando los parámetros de las funciones y los elementos de las listas. Pero, ¿qué hace aquí?

Muy simple: la coma después de una sentencia quiere decir "ejecuta la anterior sentencia y después la siguiente". Es la forma de poder ejecutar sentencias secuencialmente. En nuestro caso, queremos que imprime:lista([Cabeza|Cola]) imprima Cabeza y, después, llame a imprime:lista/1 con Cola, de manera que recorramos toda la lista.

Es interesante observar cómo se parece, en lo que a puntuación se refiere, la definición de una función en Erlang a un lenguaje "natural". Podemos "leer en voz alta" la definición de nuestra función como "Para una lista con un primer elemento Cabeza y un resto de lista Cola imprime Cabeza, llámate a ti misma con Cola; para la lista vacía devuelve ok.". Bueno, se parece más al inglés que al castellano: nosotros podríamos más comas al principio.

lista(Cola);

Tras haber impreso Cabeza, llamamos a la misma función de manera recursiva con Cola o, dicho de otro modo, procesamos el resto de la lista.

lista([]) ->

Como dije antes, la única lista que no podemos descomponer es la vacía, de manera que la anterior definición va a aplicar a todas menos a esta. Cuando hemos procesado toda la lista, la anterior definición llama a la función con la lista vacía y se ejecuta esta parte del código. Si no lo definiésemos, la lista se imprimiría igual, pero terminaríamos recibiendo un error.

ok.

Cuando llegamos al final, simplemente devolvemos el átomo "ok". En su lugar podríamos haber puesto "fin", "end" o "-1", a Erlang le da lo mismo.

Esto ha sido largo. Vamos a probar a ejecutar nuestra flamante función:

1> imprime:lista([1,2,3]).
1
2
3
ok
2> imprime:lista([[1,2,3]]).
[1,2,3]
ok
3> imprime:lista([1,[2,3]]).
1
[2,3]
ok
4> imprime:lista([]).
ok

Bien, ¿qué ha ocurrido la primera vez que hemos llamado a la imprime:lista/1?

Le hemos pasado la lista de tres elementos [1,2,3]. Como no es vacía, Erlang ha ejecutado la primera versión como imprime:lista([1|[2,3]]) (Cabeza=1, Cola=[2,3]).

Entonces nuestro código ha impreso 1 y llamado otra vez a la función con el parámetro [2,3]. Se ha vuelto a ejecutar la primera versión, invocada como imprime:lista([2,[3]]) (Cabeza=2, Cola=[3]), imprimiéndose 2 y llamándose otra vez a la función con el parámetro [3].

Esto se ha convertido en una llamada a imprime:lista([3,[]]) (Cabeza=3, Cola=[], la lista vacía), que ha impreso 3 y ha vuelto a llamar a la función, esta vez con una lista vacía como parámetro.

Llegados a este punto, ha sido la segunda versión de la función la que se ha ejecutado, devolviendo el átomo ok al shell, que este ha impreso en la última línea.

En la segunda invocación, vemos que podemos llamar a nuestra función directamente con una lista con un único elemento y, de paso, cómo imprime io:format una lista. Como se puede ver en la cuarta invocación, podemos llamar a nuestra función con una lista vacía sin problemas.

Ha llegado el momento de hacer algo más interesante que imprimir los elementos uno por uno. Vamos a coger la idea del módulo "max" de la anterior entrada y definir una nueva función que halle el máximo de entre todos los elementos de una lista.

Veamos qué hemos puesto aquí...

-export([max/2,max/1]).

Hemos modificado la sentencia -export para añadir nuestra nueva función, max/1. Como se puede observar, [max/2,max/1] también es una lista, de ahí los corchetes que hemos estado poniendo hasta ahora.

% Nuestra nueva función...

Nuestro primer comentario. Podemos poner comentarios en el código precediéndolos con un símbolo de tanto por ciento (%); llegarán hasta el final de la línea.

max([Cabeza|Cola]) when is_number(Cabeza) ->

Al igual que hicimos con max/2, queremos que Erlang de error si los parámetros no son números. Aquí nos aseguramos de que lo diga si el primer elemento de la lista no es un número; más abajo lo haremos con los demás elementos. Por lo demás, la definición de la función es sencilla.

max2(Cabeza, Cola).

Vamos a definir una nueva función, max2/2, que será la que en realidad busque el máximo. A esta función le pasamos el primer elemento de la lista y el resto de la misma.

max2(Maximo, [Cabeza|Cola])

Esta es la función. La primera versión es un poco larga. Como el nombre del parámetros sugiere, max2/2 espera recibir como primer parámetro el máximo parcial y, como segundo parámetro, la lista contra la que comparará ese máximo parcial.

when is_number(Cabeza)

Como dijimos antes, queremos que de error si algún elemento no es un número. Ya lo hicimos antes para el primero, aquí lo hacemos para los demás.

and Cabeza > Maximo ->

Esta primera versión de la función se ejecutará sólo cuando Cabeza sea mayor que máximo, es decir, cuando el máximo cambie. Cuando esto ocurra, llamaremos otra vez a la función max2/2, pasándole Cabeza como nuevo Maximo y el resto de la lista.

max2(Maximo,[_|Cola]) ->

Esta versión se ejecutará cuando no se cumpla la anterior condición, es decir, cuando Maximo sea mayor o igual a la cabeza de la lista. Como ya sabemos eso, el valor de la cabeza de la lista no nos importa, por lo que utilizamos la variable anónima, "_". Después, simplemente volvemos a llamar a max2/2 con el máximo que ya teníamos y el resto de la lista.

max2(Maximo,[]) ->

Cuando ya no quedan elementos en la lista por procesar, se ejecuta esta versión de la función, que devuelve el máximo que se le ha pasado como primer parámetro.

Lo ideal sería no haber creado una nueva función, sino haber modificado max/1 para que trabajase con listas como segundo parámetro. Además, no parece muy malo que se pueda disponer de esa nueva versión (comparar un número y una lista de números para hallar el máximo) externamente. Sin embargo, aunque no sería muy complicado de hacer, ensuciaría un poco el código.

Esto me lleva a los ejercicios para el lector. Sí, voy a proponer unos ejercicios.

• Pese a lo expresado arriba, una llamada max:max([1,2,tres,4]) no da error y devuelve 4 (tres no es un número, es un átomo). ¿Por qué? ¿Cómo se solucionaría?

• Una llamada max:max([noEsUnNumero,2,3,4]) provocará un error de Erlang "no function clause matching max:max([noEsUnNumero,2,3,4])". Modificar el código para que, como max/2, devuelva el átomo error si algún elemento de la lista no es un número.

• Como adelanté, modificar el código eliminando max2/2 e introduciendo su funcionalidad en max/2.

Dudo que nadie se anime, pero hay que intentarlo. Me queda pendiente explicar el comentario que hice sobre las cadenas, pero esta entrada ya es suficientemente larga.

Se muele el contenido casi quemado de la fuente para preparar meta-albóndigas.

(Basado en un hecho real de hace media hora)

APOSTILLA I A RECURSIVIDAD
(DE AFUERA HACIA ADENTRO)

Francisco Serradilla

Pensad un universo.
Dentro del universo en un planeta
y dentro del planeta en un país.

Elegid del país una ciudad;
dentro de la ciudad hay una calle
y en la calle una casa.

En una habitación de aquella casa
un hombre está leyendo este poema:

espejos enfrentados, infinito