How can i return a fibonacci series? Should i use IList<>?

Question

public int Fibonacci(int x)
{        
    int prev = -1;
    int next = 1;
    for (int i = 0; i < x; i++)
    {
        int sum = prev + next;
        prev = next;
        next = sum;
        Console.WriteLine(sum); 
    }
    return sum; // plz teel me how can i return whole list ??
}

How can i return whole output of above series? i.e. if x=3 then 0 1 1 2 so how can i return it?

Answer 1

Try this:

public IEnumerable<int> Fibonacci(int x)
{
    int prev = -1;
    int next = 1;
    for (int i = 0; i < x; i++)
    {
       int sum = prev + next;
       prev = next;
       next = sum;
       yield return sum;
    }
}

Answer 2

This will calculate the whole list and return it after finishing (eager evaluation):

public IEnumerable<int> Fibonacci(int x)
{
    IList<int> fibs = new List<int>();

    int prev = -1; // previous val
    int next = 1;
    for (int i = 0; i < x; i++)
    {
     int sum = prev + next;
        prev = next;
        next = sum;
        fibs.Add(sum); 
    }

    return fibs;
}

This will calculate each item and return it as it is needed (lazy evaluation), using yield:

public IEnumerable<int> Fibonacci(int x)
{
    int prev = -1;
    int next = 1;
    for (int i = 0; i < x; i++)
    {
     int sum = prev + next;
        prev = next;
        next = sum;
        yield return sum;
    }
}

Answer 3

I should say that first answer is enough but if you have big numbers, you will have overflow with int. Instead try to use ulong; we need to update that to not use -1 on prev because you cant use negatives. Instead you can try this one:

 public static IEnumerable<ulong> Generate(ulong n)
    {
        if (n < 1) yield break;
        yield return 1;
        ulong prev = 0;
        ulong next = 1;

        for (ulong i = 1; i < n; i++)
        {
            ulong sum = prev + next;
            prev = next;
            next = sum;
            yield return sum;
        }
    }

where for the first number returns 1, and more than that makes the Fibonacci using previous calculation returning positive numbers on ulong format.

Answer 4

static IEnumerable<int> Fibonacci(int n)
    {
        int a = 0, b = 1;
        yield return a;
        yield return b;
        for (int i = 0; i < n; i++)
        {
            yield return a = a + b;
            yield return b = b + a;
        }
    }

Answer 5

You return one by... returning one. It's not complicated.

public IList<int> Fibonacci(int x)
{
    List<int> result = new List<int>();

    int prev = -1;
    int next = 1;
    for (int i = 0; i < x; i++)
    {
     int sum = prev + next;
        prev = next;
        next = sum;
        result.Add(sum);
    }

    return result;
}

Answer 6

If you want to return like a list or an array of all of their numbers, you would just need something like this:

public List<int> Fibonacci(int x)
{   
    List<int> returnList = new List<int>();

    int prev = -1;
    int next = 1;
    for (int i = 0; i < x; i++)
    {
        int sum = prev + next;
        prev = next;
        next = sum;
        returnList.Add(sum);
    }
    return returnList; 
}

Answer 7

I am inspired by Andrew Hare's lazy loading fibonacci to rewrite my fibonacci before http://www.ienablemuch.com/2010/09/fibonacci-using-sql.html to lazy loading approach:

using System;
using System.Collections.Generic;

using System.Linq;

namespace Fibonacci
{
    class MainClass
    {
        public static void Main (string[] args)
        {
            Console.WriteLine("Sans list. Lazy load stuff:");
            int i = 0;


            foreach(int n in Fibonacci().Take(10))
            {
                ++i;
                Console.WriteLine("Loading {0} {1}", i, n);             
            }


            Console.WriteLine("\nPick the 20th fibonacci:");
            Console.WriteLine("\n20th fibonacci: {0}", 
                 Fibonacci().Skip(20 - 1).Take(1).Single());


            Console.WriteLine("\nEagerly load everything in list:");
            i = 0;      
            foreach(int n in Fibonacci().Take(10).ToList())
            {
                ++i;
                Console.Write("\nEager loading {0} {1}", i, n);
            }

        }



        static IEnumerable<int> Fibonacci()
        {
         int a = 0,  b = 1;

         for(;;)
         {
          Console.Write("Lazy");         
          yield return a;
          int n = a;
          a += b;
          b = n;          
         }


        }
    }//class

}

Output:

Sans list. Lazy load stuff:
LazyLoading 1 0
LazyLoading 2 1
LazyLoading 3 1
LazyLoading 4 2
LazyLoading 5 3
LazyLoading 6 5
LazyLoading 7 8
LazyLoading 8 13
LazyLoading 9 21
LazyLoading 10 34

Pick the 20th fibonacci:
LazyLazyLazyLazyLazyLazyLazyLazyLazyLazyLazyLazyLazyLazyLazyLazyLazyLazyLazyLazy
20th fibonacci: 4181

Eagerly load everything in list:
LazyLazyLazyLazyLazyLazyLazyLazyLazyLazy
Eager loading 1 0
Eager loading 2 1
Eager loading 3 1
Eager loading 4 2
Eager loading 5 3
Eager loading 6 5
Eager loading 7 8
Eager loading 8 13
Eager loading 9 21
Eager loading 10 34

At least this solution differs from others :-) this doesn't start with -1, one can use unsigned int instead of int

Answer 8

            int n = 15; 
           string r = string.Empty;
            int s=0, t=1,u;
            for (int i = 0; i < n; i++)
            {
                if (i == 0)
                {                  
                    r += Convert.ToString(s)+Convert.ToString(t);  
                }
                else
                {
                    u = s + t;
                    s = t;
                    t = u;
                    r += Convert.ToString(u);                                         
                }
            }
            MessageBox.Show(r);