N-ty wyrazu ciągu Fibonacciego – n pobierane z parametru wywołania programu

Cześć, próbuję napisać ten program już któryś raz, ale zawsze, gdy podaję konkretną cyfrę , jest w wyniku zwracana w tej samej postaci.
Pomocy.

#include <stdio.h>
#include <stdlib.h>
#include <time.h>

/* funkcja liczy n-ty wyraz ciagu Fibonacciego */
int fib(int enty)
{
    if (enty == 1 || enty == 2)
        return enty;
    else {
        return fib(enty - 1) + fib(enty - 2);
    }
}

int main(int argc, char* argv[])
{
    clock_t start, stop;
    double czas;
    start = clock();
    /* sprawdzam czy podano odpowiednia liczbe elementow i konwertuje char na int */

    int n = atol(argv[1]);
    int x;
    if (argc == 2) {
        x = fib(n);
        printf("ten wyraz ciagu jest rowny: %d", n);
    }
    else {
        printf(" Podaj liczbe n by wyliczyc n-ty wyraz ciagu: ");
        scanf("%d", &n);
        n = fib(n);

        printf("ten wyraz ciagu jest rowny: %d", n);
    }
    stop = clock();
    czas = (double)(stop - start) / (CLOCKS_PER_SEC);
    printf("czas dzialania programu %lf ", czas);
}

        x = fib(n);
        printf("ten wyraz ciagu jest rowny: %d", n);

Przypisujesz wynik do x, wypisujesz n.

Btw: atol nie zwraca inta, do którego jego wynik przypisujesz. Ponadto wykonujesz to działanie zanim sprawdzasz czy masz odpowiednią liczbę argumentów.

Zmieniłem, ale i tak nie działa :(

#include <stdio.h>
#include <stdlib.h>
#include <time.h>

/* funkcja liczy n-ty wyraz ciagu Fibonacciego */
int fib(int enty)
{
    if (enty == 1 || enty == 2)
        return enty;
    else {
        return fib(enty - 1) + fib(enty - 2);
    }
}

int main(int argc, char* argv[])
{
    clock_t start, stop;
    double czas;
    start = clock();
    /* sprawdzam czy podano odpowiednia liczbe elementow i konwertuje char na int */

    int x = 0;
    if (argc == 2) {
        int n = atoi(argv[1]);
        x = fib(n);
        printf("ten wyraz ciagu jest rowny: %d", x);
    }
    else {
        printf(" Podaj liczbe n by wyliczyc n-ty wyraz ciagu: ");
        scanf("%d", &n);
        x = fib(n);

        printf("ten wyraz ciagu jest rowny: %d", x);
    }
    stop = clock();
    czas = (double)(stop - start) / (CLOCKS_PER_SEC);
    printf("czas dzialania programu %lf ", czas);
}

No to to pewnie się nie kompiluje, bo w else nie widzisz n.

Aby przyśpieszyć to co napisałeś to możesz przechowywać powtarzające się obliczenia w pomocniczej tablicy(cache).
To się nazywa memoizacja(programowanie dynamiczne):

C++

int fib(int n) {
    static std::vector<int> table; // tablica cache
    if (n <= 1) {
        return n;
    }
    else if (n >= table.size()) {
        table.resize(n+1);
    }

    if (table[n] == 0) {
        //wywołanie jeżeli nie ma danych fib(n) w pamięci cache
        table[n] = fib(n-1) + fib(n-2); //zapis do pamięci cache
    }
    return table[n]; //zamiast obliczać to samo pobieramy wynik z pamięci cache
}

Python:

cache = {}

def fib(n):
    if n <= 1:
        return n
    if n not in cache:
        cache[n] = fib(n-1) + fib(n-2)
    return cache[n]

Java

/**
 * Project: KursJava
 * Created by R3id4k on 09.11.2017.
 */
public class Fibonacci {
    public static void main(String[] args) {

        System.out.println(metodaFibonacci(10);
    }

    public static void metodaFibonacci(int n) {
        if (n == 0) {
            return 0;
        } else if (n == 1) {
            return 1;
        } else {
            return metodaFibonacci(n - 1) + metodaFibonacci(n - 2);
        }
    }
}

Włos się jeży na głowie - Fibonacci rekurencyjnie?.

Wszyscy wrzucają to ja też ;)

#include <iostream>

int fib_iter(int num) {
  int first = 0, second = 1, result;
  for (int i = 3; i <= num;  ++i) {
    result = first + second;
    first = second;
    second = result;
  }
  if (num == 1) {
    return first;
  }
  else if (num == 2) {
    return second;
  }
  else {
  return result;
  }
} 

int main() {
  std::cout<<fib_iter(32); 
}

Wersja z 1,1 na początku będzie krótsza w zapisie

To ja też :D

uint64_t fib(uint8_t n) {
    assert(n <= 93);

    uint64_t current = 0, next = 1;
    for (int i = 0; i < n; ++i)
        swap(current += next, next);
    return current;
}