C Fibonacci (iterative)

/*	Series de Fibonacci en C
	(Forma iterativa, con un bucle)

	Este texto que estás leyendo es ignorado por el programa, ya que se encuentra
	encapsulado entre los símbolos "/ *" y "* /".
	A este tipo de textos se los llama comentarios, y son ampliamente empleados
	ya que permiten añadir explicaciones extras al código complejo sin interferir
	en la ejecución del programa.

	Ten en cuenta que aunque muchas de estas estructuras lógicas tienen análogos
	en casi todos los lenguajes, no son expresadas igual. Por ejemplo, en otros
	lenguajes el comentario sólo puede ser de una línea, y se indica con los caracteres "//".
	En otros, se utiliza una almohadilla "#".
	Lo mismo ocurre con prácticamente todas las palabras o símbolos del lenguaje.
	
	A estos símbolos del lenguaje se los conoce como "palabras reservadas".
	El nombre se debe a que estas palabras hacen referencia a funciones propias del
	lenguaje y no pueden ser utilizadas de ninguna otra forma.

	Como ejemplos, nos encontramos los símbolos "+", "-", "*", "/" que siempre significan
	sumar, restar, multiplicar y dividir (a menos que formen parte de una cadena de texto).
	Otro ejemplo pueden ser las palabras "int", "for", "if", "else" o "return", que siempre
	indican lo mismo y no pueden ser cambiadas. Lo mismo ocurre con "{" o "}", son estructuras
	de control y no podemos asignarles otra función.

	Por ejemplo, no se puede definir una variable llamada "for" o "+", ya que esos símbolos
	(o palabras) ya tienen una función definida previamente.


	Los comentarios a partir de este hacen referencia a la línea inmediatamente inferior.
*/

/*  Cargamos la librería estándar de entrada/salida, stdio,
    que nos permite leer lo que ha escrito el usuario en pantalla y a la vez escribir.
*/
#include<stdio.h> 

/*  Definimos la función main, que es la que se carga al iniciar el programa.
    Indicamos que no recibe ningún argumento, y que devuelve un número entero (int).

    Decimos que una función "devuelve" algo cuando el resultado de ejecutar el código
    contenido en la función es ese algo. Hay funciones que devuelven enteros (como esta),
    otras que devuelven cadenas de caracteres (string, es decir texto), y otros muchos
    más tipos de valores. Hay también funciones que tras ejecutarse no devuelven nada (void).

    Esto cobra sentido cuando entendemos una función como una expresión matemática.
    El resultado de esa expresión sería el valor devuelto por la función.

    La llave que va a continuación indica dónde comienza el código que forma parte
    de la función llamada "main".
*/
int main()
{
	/*  Definimos varias variables de tipo número entero;
		Una con nombre n;
		otra con nombre first, a la que le asignamos el valor 0;
		otra con nombre second, a la que le asignamos el valor 1;
		otra con nombre next;
		y otra con nombre c.

		Para separar la definición de cada variable utilizamos el símbolo ","
		y para indicar el final de la definición utilizamos ";"

		El signo ";" es muy importante, ya que es el que indica al programa
		cuándo debe dejar de leer una expresión.
	*/
	int n, first = 0, second = 1, next, c;
   
	/*  Llamamos a la función printf, con un argumento de tipo cadena de texto (string)
		de valor "Introduce el número de términos". Los símbolos "\n" significan "caracter especial n",
		abreviatura de "new line".
		Esta función escribe en pantalla el texto que se le ha pasado en el argumento.
	*/
	printf("Introduce el número de términos\n");
   
	/*  Llamamos a la función scanf, con dos argumentos.
		El primero es una cadena de texto (string) de valor "%d".
		Esto significa "tipo de valor admitido d", abreviatura de "digit".
		De esta forma, la función sólo leerá los números escritos e ignorará
		cualquier otro símbolo que escribamos.
		El segundo argumento es la variable n que definimos previamente.
		El símbolo & que la precede significa "pasar la variable por referencia".
		Esto significa que la función scanf debe asignar el valor escrito por el
		usuario a la variable n.
	*/
	scanf("%d",&n);
 
	/*  Volvemos a mostrar texto en pantalla con la función printf.
		En esta ocasión la función recibe dos argumentos. El primero sigue siendo
		el texto a mostrar en pantalla, mientras que el segundo es la variable n.
		En el texto a mostrar nos encontramos "%d". Como ya ocurrió con scanf,
		esto significa "tipo de valor admitido d", digit, número.
		La función tomará el segundo argumento, n, y lo colocará en el texto del
		primer argumento allá donde éste admita un número.
	*/
	printf("Los primeros %d términos de las series de Fibonacci son:-\n",n);
 
	/*  Definimos el inicio de un bucle a través de la palabra "for".
		El bucle necesita ciertas instrucciones sobre cómo debe comportarse.
		Para ello le pasamos tres expresiones:

		La primera expresión, "c = 0", indica que el bucle va a contar con la
		variable de nombre c, y que ésta comienza con el valor 0.

		La segunda expresión, "c < n", es la condición de ejecución del bucle.
		Es decir, en qué casos se ejecutarán las instrucciones del interior del bucle.
		Cuando la condición deje de cumplirse, el bucle se terminará.
		En este caso, la condición es "c debe ser menor que n".

		La tercera expresión, "c++", es la forma en la que cambia el valor asignado a
		la variable c al final de cada paso del bucle. En este caso, al final de cada
		paso se sumará 1 al valor de la variable c. Esto es así porque "++" significa
		"toma el valor previo y súmale 1". Otra forma válida de indicar lo mismo podría
		haber sido "c+=1", o "c=c+1". Esta última es la más parecida al lenguaje humano.
	*/
	for ( c = 0 ; c < n ; c++ )
	{

		/*	Antes de comentar el código siguiente, fijémonos en la llave que va justo tras
			definir el inicio del bucle. Las llaves {} indican qué parte del código se ejecuta
			dentro del bucle for. Todo lo que vaya entre esos dos signos se ejecutará únicamente
			si la condición del bucle ("c < n") se cumple.


			Definimos una condición a través de la palabra "if".
			La condición admite cualquier expresión que pueda evaluarse como verdadera o falsa.
			En este caso, la condición es "c <= 1", es decir, "c es menor o igual a 1".
			El código dentro del bloque "if" sólo se ejecutará si esta condición se cumple,
			es decir, si "c <=1 " es verdadera (true).
		*/
		if ( c <= 1 )
		{

			/*	Como ocurrió al definir el bucle, indicamos qué código debe ejecutarse
				si se cumple la condición (if) encapsulándolo entre llaves.

				Asignamos a la variable llamada "next" el valor de la variable "c".
				Al hacer esto, next pasará a tener el mismo valor numérico que c.
				Esto equivale a una copia; la variable c seguirá teniendo el mismo valor.
			*/
			next = c;
		}

		/*	La palabra "else" indica un bloque de código que sólo se ejecutará si la
			condición previa no se cumple.

			En este caso, el código siguiente sólo se ejecutará si "c <= 1" es falso (false).
		*/
		else
		{
			/*	Asignamos a la variable "next" el valor de la expresión "first + second".
				Es decir, "next" pasará a tener como valor el resultado de la suma de
				los valores de las variables "first" y "second".
			*/
			next = first + second;

			/*	Asignamos a la variable "first" el valor de la variable "second". */
			first = second;

			/*	Asignamos a la variable "second" el valor de la variable "next". */
			second = next;
		}

		/*	Mostramos en pantalla el valor de la variable "next" y pasamos a la línea siguiente. */
		printf("%d\n",next);
   }

	/*	Hemos salido del bucle. El código a partir del signo "}" sólo se ejecuta tras haber completado
   		el bucle. Es decir, cuando la condición por la cual se ejecutaba el bucle ya no es verdadera.
	*/

   	/*	Utilizamos la palabra reservada "return" para indicar que salimos de la función "main".
   		De esta forma indicamos qué "devuelve" la función. En este caso, el valor 0.
   	*/
   	return 0;
}

C Fibonacci (recursive)

/*	Series de Fibonacci en C
	(Forma recursiva, con una función)
*/

#include<stdio.h>
 
int Fibonacci(int);
 
main()
{
   int n, i = 0, c;
 
   scanf("%d",&n);
 
   printf("Fibonacci series\n");
 
   for ( c = 1 ; c <= n ; c++ )
   {
      printf("%d\n", Fibonacci(i));
      i++; 
   }
 
   return 0;
}
 
int Fibonacci(int n)
{
   if ( n == 0 )
      return 0;
   else if ( n == 1 )
      return 1;
   else
      return ( Fibonacci(n-1) + Fibonacci(n-2) );
} 

C++ Fibonacci (iterative)

//	Series de Fibonacci en C++
//	(Forma iterativa, con un bucle)

#include <iostream>

using namespace std;

int main()
{
    int num1 = 0;
    int num2 = 1;
    int num_temp;
    int num_next = 1;
    int n;
    cin >> n;
    if (n>=1)
        cout << num1 << " ";
    if (n>=2)
        cout << num2 << " ";
    for (int i = 0; i < n-2; i++){
        num_next = num1 + num2;
        cout << num_next << " ";
        num1 = num2;
        num2 = num_next;
    }
    cout << endl;
    return 0;
}

Golang Fibonacci (recursive)

//	Series de Fibonacci en Go
//	(Forma recursiva, con una función)

package main

import "fmt"

func fib() func() int {
	a, b := 0, 1
	return func() int {
		a, b = b, a+b
		return a
	}
}

func main() {
	f := fib()
	// Function calls are evaluated left-to-right.
	fmt.Println(f(), f(), f(), f(), f())
}

Javascript Fibonacci (iterative)

/*	Series de Fibonacci en Javascript
	(Forma iterativa, con un bucle)
*/

function fibonacci(numero)
{
    var var1 = 0;
    var var2 = 1;
    var var3;

    document.write(var1+"");
    document.write(var2+"");

    for(var i=3; i <= numero;i++)
    {
        var3 = var1 + var2;
        var1 = var2;
        var2 = var3;
        document.write(var3+"");
    }
}

fibonacci(10);

Python Fibonacci (recursive)

#	Series de Fibonacci en Python
#	(Forma recursiva, con una función)
def fib(n):
    if n == 0:
        return 0
    elif n == 1:
        return 1
    else:
        return fib(n-1) + fib(n-2)

fib(10);

Ruby Fibonacci (recursive)

#	Series de Fibonacci en Ruby
#	(Forma recursiva, con una función)

def fibonacci( n )
    return  n  if n <= 1 
    fibonacci( n - 1 ) + fibonacci( n - 2 )
end 
puts fibonacci( 10 )

Rust Fibonacci (recursive)

//	Series de Fibonacci en Rust
//	(Forma recursiva, con una función)

use std::mem;

struct Fibonacci {
    curr: uint,
    next: uint,
}

impl Iterator<uint> for Fibonacci {
    fn next(&mut self) -> Option<uint> {
        let new_next = self.curr + self.next;
        let new_curr = mem::replace(&mut self.next, new_next);

        Some(mem::replace(&mut self.curr, new_curr))
    }
}

fn fibonacci() -> Fibonacci {
    Fibonacci { curr: 1, next: 1 }
}

fn main() {
    let mut sequence = range(0u, 3);

    println!("Four consecutive `next` calls on range(0, 3)")
    println!("> {}", sequence.next());
    println!("> {}", sequence.next());
    println!("> {}", sequence.next());
    println!("> {}", sequence.next());

    println!("Iterate over range(0, 3) using for");
    for i in range(0u, 3) {
        println!("> {}", i);
    }

    println!("The first four terms of the Fibonacci sequence are: ");
    for i in fibonacci().take(4) {
        println!("> {}", i);
    }

    println!("The next four terms of the Fibonacci sequence are: ");
    for i in fibonacci().skip(4).take(4) {
        println!("> {}", i);
    }

    let array = [1u, 3, 3, 7];

    println!("Iterate the following array {}", array.as_slice());
    for i in array.iter() {
        println!("> {}", i);
    }
}