Imprimer les nombres de fibonacci jusqu'tp de 15 000 C#

J'ai vu des questions similaires(mais en C) -- Le calcul des Nombres de Fibonacci de manière Récursive en C au sujet de mon problème.

Je suis un peu coincé sur la façon de garder à l'impression des nombres de fibonacci jusqu'à ce qu'il atteigne environ 40 000 personnes, en C# dans mon application console, Comment puis-je y parvenir?

E. G, je veux que la demande pour ce faire:

0
1
1
2
3
5
8

and so on.

Grâce.
Je déteste dire cela, mais j'ai eu une trouvaille, et résolu!

Voici ce que j'ai fait:

static void Main(string[] args)
{
    int num1 = 0;
    int num2 = 1;
    int sum = 1;
    while (num1 <= 15000)
    {
        sum = num1 + num2;
        num1 = num2;
        num2 = sum;
       Console.WriteLine(num2);
    }
    Console.ReadLine();
}

Finalement, vous n'en avaient plus d'espace de pile si vous procédez de cette manière récursive, ce qui va se passer bien avant que se termine jamais.
Si c'est de manière récursive, vous vous retrouverez avec un débordement de pile, tôt ou tard.
Qu'avez-vous fait jusqu'à présent? Qu'est-ce spécifiquement êtes-vous à avoir des problèmes avec? Montre-nous ton code. Souvent, les gens veulent que les autres à faire leurs devoirs pour eux si vous avez besoin de nous montrer que vous essayez avant que les gens de l'aide.
Êtes-vous de demander de l'aide de la conversion de C à C# dans l'exemple ci-dessus?
Vous avez besoin d'une sorte de sortie de vérifier dans votre récursivité fonction pour vérifier votre 40k condition.
Vous pouvez déballer tout algorithme récursif dans un processus itératif, à l'aide d'une boucle while et une variable d'état.
Désolé, j'ai mis à jour avec une référence à ce que j'ai fait jusqu'à présent.
Je ne suis pas de faire ses devoirs.
Ce serait bien si C# pourrait faire la queue la récursivité...
Aucune idée de pourquoi voulez-vous exécuter ce pour toujours. Je ne suis pas C# expert, mais j'ai entendu C# a quelques fonctionnelle de la programmation des fonctions. Peut-être que si vous voulez une suite infinie vous pourriez mettre en œuvre certaines paresseux séquence ou quelque chose?
L'algorithme récursif de Fibonacci est dans la question. Vous nous demandez de faire votre propre travail pour vous, si ce n'est en effet pas de devoirs, que je trouve difficile à croire.
Je peux garantir à 100% que ce n'est pas de devoirs. Et je l'ai résolu.
Ce que vous avez modifié dans n'est pas récursive.
Certaines versions de la gigue va faire la queue de la récursivité. Cependant, depuis fib se répète deux fois dans un typique récursive mise en œuvre, il n'est pas trivial de le transformer en une queue-forme récursive. Notez aussi que même si vous pourriez transformer en une queue récursive forme, la naïve récursive fib est toujours exponentielle dans le temps. Si vous voulez une solution récursive, préférable d'utiliser un memoizer; mieux encore est d'utiliser une solution itérative ou de calculer les nombres directement en utilisant le nombre d'Or.
Comme @EricLippert mentiones, utilisez la forme fermée de la solution de stackoverflow.com/a/8334397/8384
eh bien, qui m'a convaincu.
stackoverflow.com/a/8333602/901059

InformationsquelleAutor H Bellamy | 2011-11-30

c#fibonacci loops

Comment parler de quelque chose qui a une boucle? Comme:

    static void main() 
    {
        int num1 = 0;
        int num2 = 1;
        int sum = 1;
        Console.WriteLine(num1);
        while (sum < 40000)
        {
           sum = num1 + num2;
           num1 = num2;
           num2 = sum;    
           Console.WriteLine(num2);
        }
    }

Vous pouvez également le faire avec une boucle for avec de multiples variables: for(int premier=0,seconde=1,le courant=0;premier<100;courant=premier+second,premier=deuxième,deuxième=courant) { Console.WriteLine(première); }

InformationsquelleAutor piebie

Juste pour le fun, j'ai pensé jeter dans une façon amusante de faire cela avec LINQ méthodes d'extension et d'un générateur (suite infinie):

//A utility class that holds math utility functions.
public static class MathUtility
{
    //This method returns the fibonacci sequence which is an 
    //infinite sequence of numbers where each result is the
    //sum of the previous two results.
    public static IEnumerable<int> GetFibonacciSequence()
    {
        int first = 0;
        int second = 1;

        //first and second result are always 1.
        yield return first;
        yield return second;

        //this enumerable sequence is bounded by the caller.
        while(true)
        {
            int current = first + second;
            yield return current;

            //wind up for next number if we're requesting one
            first = second;
            second = current;
        }
    }
}

Cela génère une infinie (théoriquement) de la séquence (il finira par déborder si vous le laissez aller au-delà de gamme de type int).

Vous pouvez ensuite appeler:

foreach(var num in MathUtility.GetFibonacciSequence().TakeWhile(num => num <= 40000))
{
    Console.WriteLine(num);
}

De cette façon, vous avez votre présentation (la sortie), séparé de la génération des données.

InformationsquelleAutor James Michael Hare

static int Fibonacci(int n)
{
    if(n <= 1) return n;
    else return Fibonacci(n - 1) + Fibonacci(n - 2);
}


static void PrintAllFibonacci()
{
    int n = 0;
    while(true)
        Console.WriteLine(Fibonacci(n++));
}

EDIT:

une approche différente à l'aide d'une pile

static ulong Fibonacci(int n, IList<ulong> stack)
{
    ulong fibonacci;

    if (n <= 1)
    {
        fibonacci = (ulong)n;
    }
    else
    {
        ulong n1, n2;
        if (n < stack.Count)
            n1 = stack[n - 1];
        else
            n1 = Fibonacci(n - 1, stack);
        if (n - 1 < stack.Count)
            n2 = stack[n - 2];
        else
            n2 = Fibonacci(n - 2, stack);

        fibonacci = n1 + n2;
    }

    if (n >= stack.Count)
        stack.Add(fibonacci);

    return fibonacci;
}


static void PrintAllFibonacci()
{
    var stack = new List<ulong>();
    var n = 0;
    while(n < 50)
        Console.WriteLine(n + ") " + Fibonacci(n++, stack));
}

Votre Fibonacci(n) a exponentiel de l'exécution dans n. Heureusement, la valeur des nombres de fibonacci aussi croît de façon exponentielle, de sorte que le 40k limite est tout de même atteint rapidement.
J'ai écrit qu'avant de @HBellamy editet sa question!
Il est possible d'écrire un rapide une version récursive d'un nombre de Fibonacci générateur. Soit par memoization, ou à l'aide de plusieurs paramètres.
a ajouté une autre approche à l'aide d'une pile!

InformationsquelleAutor esskar

1

Vous ne pouvez pas le faire de manière récursive - rappelez-vous que chaque appel de méthode utilise vous de la pile. Google, hein, de débordement de pile 🙂

Vous aurez besoin de trouver une itération de la version de l'algorithme, il est partout sur internet. Et, bien sûr, tout fib chiffres sont assez rapidement en cours d'exécution, il est impossible à la sortie de la vie.
- Je me doute que tu avais atteint un débordement de pile avec un 40k limite sur la taille de la nombre. Je ne serais même pas surpris si vous avais atteint la valeur maximale double peut représenter avant d'exécuter hors de la pile. À l'aide de BigInteger, vous pouvez probablement obtenir un débordement de la pile, mais il sera bien au-delà de l'OP limite. Et certaines versions de la .net de la gigue de soutien de la queue d'appel de récursivité qui(en supposant un appel récursif à la mise en œuvre qui permet d'appel tail récursivité) rend cette O(1) dans l'espace de pile.
- Oh, je ne savais pas pour la queue d'appel de récursivité dans .net, intéressant!
- Puisque cette forme de la queue de la récursivité n'est pas garanti, vous ne pouvez pas compter sur elle, et donc c'est la plupart du temps inutile. Donc pour la fiabilité de la queue des appels, vous devez utiliser le tailcall instruction IL, mais le compilateur C# ne pas le faire.
InformationsquelleAutor Piotr Zierhoffer

Utiliser le Fermé solution de la forme

    public static long ClosedFormFibonacci(int i)
    {
        const double phi = 1.61803398874989; //or use your own or calculate it
        const double sqrt5 = 2.23606798; //same as above
        return (long)Math.Round(Math.Pow(phi, i) / sqrt5);
    }

On dirait qu'il déborde de long à peu près à la 92e nombre de Fibonacci

InformationsquelleAutor McKay

0

C# n'est pas facilement prendre en charge la queue de la récursivité, donc en faisant un simple récursivité algorithme va provoquer un débordement de pile avec d'assez grands nombres. Pour ce problème, il serait plus simple d'utiliser une boucle au lieu de la récursivité. Si vous êtes vraiment coincé sur la récursivité, ici est un blog qui explore à la fois semblant de récursivité et de la conversion de C# généré IL code pour utiliser la queue de la récursivité.

InformationsquelleAutor mydogisbox
0

Il y a 2 grosses erreurs dans votre programme:
1. Utilisation Multiple de main()
2. fibonacci_recursive n'est pas créée, mais elle est déclarée au début de programme.
InformationsquelleAutor Bebu

Vous devez vous connecter pour publier un commentaire.