c# - refactorizacion - refactorizar css

Refactorización del algoritmo de Fibonacci

Question

No utilicé un lenguaje estáticamente tipado en muchos años y me he impuesto la tarea de ponerme al día con C #. Estoy utilizando mi truco habitual de seguir los quince ejercicios aquí http://www.jobsnake.com/seek/articles/index.cgi?openarticle&8533 como mi primera tarea.

Acabo de terminar la segunda tarea de Fibonacci que no tardó mucho y funciona bien, pero en mi opinión se ve fea y estoy seguro de que se podría lograr en muchas menos líneas de código más elegante.

Por lo general, me gusta aprender por programación de pares con alguien que ya sabe lo que están haciendo, pero esa opción no está abierta para mí hoy, así que espero publicar aquí será la mejor opción.

Entonces, para todos los C # Jedi, si fueran a refactorizar el código a continuación, ¿cómo se vería?

using System;
using System.Collections;

namespace Exercises
{
    class MainClass
    {
        public static void Main(string[] args)
        {
            Console.WriteLine("Find all fibinacci numbers between:");
            int from = Convert.ToInt32(Console.ReadLine());
            Console.WriteLine("And:");
            int to = Convert.ToInt32(Console.ReadLine());
            Fibonacci fibonacci = new Fibonacci();
            fibonacci.PrintArrayList(fibonacci.Between(from, to));

        }
    }

    class Fibonacci
    {   
        public ArrayList Between(int from, int to)
        {               
            int last = 1;
            int penultimate = 0;
            ArrayList results = new ArrayList();
            results.Add(penultimate);
            results.Add(last);

            while(last<to)
            {
                int fib = last + penultimate;
                penultimate = last;
                last = fib;
                if (fib>from && fib<to) results.Add(fib.ToString());
            }
            return results;
        }

        public void PrintArrayList(ArrayList arrayList)
        {
            Console.WriteLine("Your Fibonacci sequence:");
            Console.Write(arrayList[0]);
            for(int i = 1; i<arrayList.Count; i++)
            {
                Console.Write("," + arrayList[i]);
            }
            Console.WriteLine("");
        }

    }
}

Saludos,

Chris

Answer 1

Cambiaría el tipo IEnumerable<int> a IEnumerable<Int64> ya que comenzará a desbordarse desde 50

Answer 2

Para aquellos que no han cedido a Linq-ed en como yo, la versión ''Simple Jack''. estoy TAN prohibido salir del club Jedi;)

static List<int> GetAllFibonacciNumbersUpto(int y)
{
   List<int> theFibonacciSeq = new List<int>();

   theFibonacciSeq.Add(0);   theFibonacciSeq.Add(1);

   int F_of_n_minus_2 = 0;   int F_of_n_minus_1 = 1;
   while (F_of_n_minus_2 <= y)
   {
      theFibonacciSeq.Add(F_of_n_minus_1 + F_of_n_minus_2);

      F_of_n_minus_2 = F_of_n_minus_1;
      F_of_n_minus_1 = theFibonacciSeq.Last<int>();
   }
   return theFibonacciSeq;
}

ahora que tenemos eso fuera del camino ...

// read in some limits
int x = 0; int y = 6785;

foreach (int iNumber in GetAllFibonacciNumbersUpto(y).FindAll(element => (element >= x) && (element <= y)))
    Console.Write(iNumber + ",");
Console.WriteLine();

Answer 3

Si prefiere la recursión en lugar del bucle:

public static void Main(string[] args)
{
    Func<int, int> fib = null;
    fib = n => n > 1 ? fib(n - 1) + fib(n - 2) : n;

    int start = 1;
    int end = 10;
    var numbers = Enumerable.Range(start, end).Select(fib);
    foreach (var number in numbers)
    {
        Console.WriteLine(number);
    }
}

Answer 4

Como un bloque iterador:

using System;
using System.Collections.Generic;
using System.Linq;

static class Program {
    static IEnumerable<long> Fibonacci() {
        long n = 0, m = 1;

        yield return 0;
        yield return 1;
        while (true) {
            long tmp = n + m;
            n = m;
            m = tmp;
            yield return m;
        }
    }

    static void Main() {
        foreach (long i in Fibonacci().Take(10)) {
            Console.WriteLine(i);
        }
    }
}

Esto ahora es totalmente vago, y usar Skip / Take LINQ, etc., le permite controlar el inicio / finalización fácilmente. Por ejemplo, para su consulta "entre":

foreach (long i in Fibonacci().SkipWhile(x=>x < from).TakeWhile(x=>x <= to)) {...}