A sequência de Fibonacci é uma sequência que começa com os termos 0 e 1, e cada próximo valor será sempre a soma dos dois valores imediatamente anteriores: 0,1,1,2,3,5 ldots
Junte todos os trechos de código solicitados nos exercícios a seguir em um código só, completo, conforme o que se pede.
Crie a função main de forma que ela tenha as seguintes coisas:
a) uma variável do tipo fibonacci;
b) uma chamada da função da letra c) tendo o valor do último dígito de seu RA mais um como parâmetro.
c) um print na tela mostrando o total de chamadas recursivas feitas e o valor do termo de acordo com o parâmetro informado no item anterior.

Passo 1

Beleza, o exercício quer que a gente monte um programa em C que calcule um termo da sequência de Fibonacci de forma recursiva e, ao mesmo tempo, conte quantas vezes essa função recursiva foi chamada. A gente vai mexer com:
  • Recursão (chamada de função dentro dela mesma)
  • Sequência de Fibonacci, definida por
    • para ,
  • Operador módulo (para pegar o último dígito do RA)
  • Variáveis globais (para contar as chamadas)
  • Função main que:
    a) declara uma variável para guardar o resultado de Fibonacci;
    b) calcula o parâmetro como “último dígito do RA + 1”;
    c) imprime o número de chamadas recursivas e o valor do termo.

Passo 2

Primeiro, vamos criar uma variável global chamada chamadas que vai armazenar quantas vezes a função Fibonacci for invocada. Usar global facilita o acesso de qualquer função do programa:
int chamadas = 0;  // contador de chamadas recursivas
Aqui, toda vez que a gente entrar na função fibonacci, incrementamos chamadas++.

Passo 3

Agora implementamos a função recursiva de Fibonacci. A ideia é:
  1. Sempre que alguém chamar fibonacci(n), antes de tudo a gente faz chamadas++.
  2. Se , retorna 0; se , retorna 1. Esses são os casos-base, evitando recursão infinita.
  3. Caso contrário, retorna fibonacci(n-1) + fibonacci(n-2).
Em código:
int fibonacci(int n) {
    chamadas++;          // aumento do contador
    if (n == 0) return 0;  
    if (n == 1) return 1;  
    return fibonacci(n-1) + fibonacci(n-2);
}
Teoria rápida: recursão é quando uma função se chama de novo até bater num caso simples (os “casos-base”). Aqui, os casos-base são n = 0 e n = 1.

Passo 4

Vamos montar a função main com o que o enunciado pediu:
a) Declarar uma variável para guardar o resultado de Fibonacci, tipo int resultado;.
b) Pegar o RA (você pode substituir meu exemplo pelo seu):
int RA = 1234567;           
int ultimoDigito = RA % 10; // operador módulo: resto da divisão por 10
int parametro = ultimoDigito + 1;
c) Chamar fibonacci(parametro) e guardar em resultado, depois imprimir chamadas e resultado na tela.
O operador % faz , ou seja, devolve o último dígito de RA.

Passo 5

Agora é só juntar tudo num código só, bem organizado:

Resposta

#include <stdio.h>

// Variável global para contar chamadas recursivas
int chamadas = 0;

// Função recursiva de Fibonacci
int fibonacci(int n) {
    chamadas++;           // conta a chamada
    if (n == 0) return 0; // caso-base 1
    if (n == 1) return 1; // caso-base 2
    return fibonacci(n-1) + fibonacci(n-2); // recursão
}

int main() {
    // a) Variável para guardar o resultado
    int resultado;
    
    // b) Cálculo do parâmetro: último dígito do RA + 1
    int RA = 1234567;          
    int ultimoDigito = RA % 10;
    int parametro = ultimoDigito + 1;
    
    // chama a função recursiva
    resultado = fibonacci(parametro);
    
    // c) imprime quantidade de chamadas e valor do termo
    printf("Total de chamadas recursivas: %d\n", chamadas);
    printf("Termo Fibonacci de n = %d: %d\n", parametro, resultado);
    
    return 0;
}
Basta substituir 1234567 pelo seu RA, compilar e rodar. Feito!

Exercícios relacionados