C Fibonacci Sequencia em par

[StyleReset]

 

Galera gostária de saber como faço pra fazer a somar da sequencia em par

 

void main()
{
  int a, b, auxiliar, i, n;

  a = 0;
  b = 1;
 
  printf("Digite um número: ");  scanf("%d", &n);
  printf("Série de Fibonacci:\n");
  printf("%d\n", b);
 
  for(i = 0; i < n; i++)
  {
    auxiliar = a + b;
    a = b;
    b = auxiliar;
                   
    printf("%d\n", auxiliar);
  }
}

 

[arfneto]

Olá!

 

Se você tiver uma função bem amiga declarada assim:

int proximo_fibonacci(int);

E que:

• se você chamar proximo_fibonacci(0) ela retorna 1, e inicia a sequência, como quando você chama rand(1)
• E a partir daí ela retorna o próximo número na sequência se você chamar com qualquer outro argumento

Então

 

basta você usar um loop e ir somando os valores pares até algum estourar o limite. Algo assim:

    proximo_fibonacci(0);    // inicia a sequencia
    do
    {
        v = proximo_fibonacci(1);
        if(v>limite)
        {
            printf("Soma dos valores pares (limite=%ld): %ld\n", limite, soma);
            return 0;
        }
        if ((v % 2) == 0) soma += v;
    } while (1);

Resolve. Eis uma saída de um programa de exemplo:

Usando limite de 4000000
Soma dos valores pares (limite=4000000): 4613732

Pegadinha

Atenção para esses valores: declare tudo como unsigned ou vai passar do limite. Ou se quiser ir além declare tudo como unsigned long e use as mascaras %ld no printf() e assim pode testar para valores bem maiores

 

E essa função? Pode ser assim:

long proximo_fibonacci(int n)
{
    static long ultimo;
    static long penultimo;
    long        proximo;
    if (n==0)
    {
        ultimo = 1;
        penultimo = 0;
        return 1;
    }
    proximo = ultimo + penultimo;
    penultimo = ultimo;
    ultimo = proximo;
    return proximo;
}    // end proximo_fibonacci()

 

Esse programa exemplo permite que você teste usando limites menores para poder acompanhar com a calculadora. Se o programa se chamar fb você pode usar fb 200 ou fb 2000 ou fb 5000000 e se usar só fb ele assume o limite de 4 milhões...
 

#include "stdio.h"
#include "stdlib.h"

long proximo_fibonacci(int n)
{
    static long ultimo;
    static long penultimo;
    long        proximo;
    if (n==0)
    {
        ultimo = 1;
        penultimo = 0;
        return 1;
    }
    proximo = ultimo + penultimo;
    penultimo = ultimo;
    ultimo = proximo;
    return proximo;
}    // end proximo_fibonacci()


int main(int argc, char** argv)
{
    unsigned int    limite;
    unsigned int    soma = 0;
    unsigned int    v;

    if (argc > 1)
    {
        limite = atol(argv[1]);
    }
    else
    {
        limite = 4000000L;
    }    // end if
    printf("Usando limite de %d\n", limite);
    proximo_fibonacci(0);    // inicia a sequencia
    do
    {
        v = proximo_fibonacci(1);
        if(v>limite)
        {
            printf("Soma dos valores pares (limite=%d): %d\n", limite, soma);
            return 0;
        }
        if ((v % 2) == 0) soma += v;
    } while (1);
}    // end main()

e gera aquele resultado acima... Uma pequena mudança no código e gera assim para facilitar, mostrando a posição do valor na série e o valor:

Usando limite de 4000000
Soma dos valores pares (limite=4000000): 4613732
[3] 2
[6] 8
[9] 34
[12] 144
[15] 610
[18] 2584
[21] 10946
[24] 46368
[27] 196418
[30] 832040
[33] 3524578

Soma dos valores pares (limite=4000000): 4613732

Que mudança? Essa:
 

    printf("Usando limite de %d\n", limite);
    proximo_fibonacci(0);    // inicia a sequencia
    do
    {
        v = proximo_fibonacci(1);
        if(v>limite)
        {
            printf("Soma dos valores pares (limite=%d): %d\n", limite, soma);
            break;
        }
        if ((v%2)==0) soma += v;
    } while (1);
    // de novo com mais detalhes
    soma = 0;
    sequencia = 1;
    proximo_fibonacci(0);    // inicia a sequencia
    do
    {
        v = proximo_fibonacci(1);
        sequencia += 1;
        if (v > limite)
        {
            printf("\nSoma dos valores pares (limite=%d): %d\n", limite, soma);
            return 0;
        }
        if ((v%2)==0)
        {
            printf("[%d] %ld\n", sequencia, v);
            soma += v;
        }
    } while (1);

Não se esqueça de trocar o return pelo break no primeiro loop  Eu esqueci!  

 

 

 

[StyleReset]

19 horas atrás, arfneto disse:

Olá!

 

Se você tiver uma função bem amiga declarada assim:

int proximo_fibonacci(int);

E que:

• se você chamar proximo_fibonacci(0) ela retorna 1, e inicia a sequência, como quando você chama rand(1)
• E a partir daí ela retorna o próximo número na sequência se você chamar com qualquer outro argumento

Então

 

basta você usar um loop e ir somando os valores pares até algum estourar o limite. Algo assim:

    proximo_fibonacci(0);    // inicia a sequencia
    do
    {
        v = proximo_fibonacci(1);
        if(v>limite)
        {
            printf("Soma dos valores pares (limite=%ld): %ld\n", limite, soma);
            return 0;
        }
        if ((v % 2) == 0) soma += v;
    } while (1);

Resolve. Eis uma saída de um programa de exemplo:

Usando limite de 4000000
Soma dos valores pares (limite=4000000): 4613732

Pegadinha

Atenção para esses valores: declare tudo como unsigned ou vai passar do limite. Ou se quiser ir além declare tudo como unsigned long e use as mascaras %ld no printf() e assim pode testar para valores bem maiores

 

E essa função? Pode ser assim:

long proximo_fibonacci(int n)
{
    static long ultimo;
    static long penultimo;
    long        proximo;
    if (n==0)
    {
        ultimo = 1;
        penultimo = 0;
        return 1;
    }
    proximo = ultimo + penultimo;
    penultimo = ultimo;
    ultimo = proximo;
    return proximo;
}    // end proximo_fibonacci()

 

Esse programa exemplo permite que você teste usando limites menores para poder acompanhar com a calculadora. Se o programa se chamar fb você pode usar fb 200 ou fb 2000 ou fb 5000000 e se usar só fb ele assume o limite de 4 milhões...
 

#include "stdio.h"
#include "stdlib.h"

long proximo_fibonacci(int n)
{
    static long ultimo;
    static long penultimo;
    long        proximo;
    if (n==0)
    {
        ultimo = 1;
        penultimo = 0;
        return 1;
    }
    proximo = ultimo + penultimo;
    penultimo = ultimo;
    ultimo = proximo;
    return proximo;
}    // end proximo_fibonacci()


int main(int argc, char** argv)
{
    unsigned int    limite;
    unsigned int    soma = 0;
    unsigned int    v;

    if (argc > 1)
    {
        limite = atol(argv[1]);
    }
    else
    {
        limite = 4000000L;
    }    // end if
    printf("Usando limite de %d\n", limite);
    proximo_fibonacci(0);    // inicia a sequencia
    do
    {
        v = proximo_fibonacci(1);
        if(v>limite)
        {
            printf("Soma dos valores pares (limite=%d): %d\n", limite, soma);
            return 0;
        }
        if ((v % 2) == 0) soma += v;
    } while (1);
}    // end main()

e gera aquele resultado acima... Uma pequena mudança no código e gera assim para facilitar, mostrando a posição do valor na série e o valor:

Usando limite de 4000000
Soma dos valores pares (limite=4000000): 4613732
[3] 2
[6] 8
[9] 34
[12] 144
[15] 610
[18] 2584
[21] 10946
[24] 46368
[27] 196418
[30] 832040
[33] 3524578

Soma dos valores pares (limite=4000000): 4613732

Que mudança? Essa:
 

    printf("Usando limite de %d\n", limite);
    proximo_fibonacci(0);    // inicia a sequencia
    do
    {
        v = proximo_fibonacci(1);
        if(v>limite)
        {
            printf("Soma dos valores pares (limite=%d): %d\n", limite, soma);
            break;
        }
        if ((v%2)==0) soma += v;
    } while (1);
    // de novo com mais detalhes
    soma = 0;
    sequencia = 1;
    proximo_fibonacci(0);    // inicia a sequencia
    do
    {
        v = proximo_fibonacci(1);
        sequencia += 1;
        if (v > limite)
        {
            printf("\nSoma dos valores pares (limite=%d): %d\n", limite, soma);
            return 0;
        }
        if ((v%2)==0)
        {
            printf("[%d] %ld\n", sequencia, v);
            soma += v;
        }
    } while (1);

Não se esqueça de trocar o return pelo break no primeiro loop  Eu esqueci!  

 

 

 

Nossa cara bem bacana me ajudou muito mesmo viu bela explicação e caso eu queira fazer isso em C# teria outra forma mais simples?

[arfneto]

14 horas atrás, StyleReset disse:

Nossa cara bem bacana me ajudou muito mesmo viu bela explicação e caso eu queira fazer isso em C# teria outra forma mais simples?

 

Não acho que mudar a linguagem possa mudar algo. A função proximo_fibonacci() é a própria definição matemática da série: proximo = ultimo+penultimo. E o fato de devolver sempre o próximo economiza um loop. E são só umas 8 linhas.

 

O programa principal é como a realidade do enunciado: você vai pegando os valores da sequencia e se for par soma até um limite. Ao atingir o limite você mostra e termina. Só isso.  E tem umas dez linhas.

 

Mudar a linguagem vai ficar igual eu acho. Desde que a linguagem tenha variáveis estáticas em funções definidas pelo usuário, porque se não for o caso seria preciso mudar o algoritmo. 

[StyleReset]

1 hora atrás, arfneto disse:

 

Não acho que mudar a linguagem possa mudar algo. A função proximo_fibonacci() é a própria definição matemática da série: proximo = ultimo+penultimo. E o fato de devolver sempre o próximo economiza um loop. E são só umas 8 linhas.

 

O programa principal é como a realidade do enunciado: você vai pegando os valores da sequencia e se for par soma até um limite. Ao atingir o limite você mostra e termina. Só isso.  E tem umas dez linhas.

 

Mudar a linguagem vai ficar igual eu acho. Desde que a linguagem tenha variáveis estáticas em funções definidas pelo usuário, porque se não for o caso seria preciso mudar o algoritmo. 

Assim obrigado irei tentar fazer isso

[arfneto]

44 minutos atrás, StyleReset disse:

Assim obrigado irei tentar fazer isso

 

Muito bem. Posta aqui a solução quando escrever. Ou em C++

adicionado 2 minutos depois

16 horas atrás, StyleReset disse:

Usando limite de 4000000 Soma dos valores pares (limite=4000000): 4613732

[3] 2

[6] 8

[9] 34

[12] 144

[15] 610

[18] 2584

[21] 10946

[24] 46368

[27] 196418

[30] 832040

[33] 3524578

 

Acho que esse problema foi composto para mostrar essa particularidade da sequencia: um par é seguido por dois ímpares sempre  

 

aqui não é o forum de matemática mas deve ser fácil de provar que vale para a sequência toda