Alle geraden Fibonacci Zahlen summieren

skullyan

SeppJ schrieb:

skullyan schrieb:

Nexus schrieb:

Du würdest bei dem Code schon viel mehr durchblicken, wenn du statt s, k und p sinnvolle Bezeichner nehmen und deinen Code in Funktionen aufteilen würdest. Konsistente Einrückung wäre auch eine Idee.

Stimmt, aber wie schaut denn jetzt die Lösung aus?

Versuch doch lieber noch mal von vorne anzufangen und dabei das was Nexus gesagt hat umzusetzen.

Das bringt mir jetzt herzlich wenig, aber naja... Dann werde ich es wohl aufgeben müssen.

freaky

Oh mein Gott, wenn ich so ein Bullshit höre, krieg ich echt Magenkrämpfe. Erwartest du echt das du hier die Lösung hingespuckt bekommst und dann sagen kannst "Ich habe es geschafft"? Du machst das grad damit du es lernen kannst. Aber gut, bleib dumm.

Ich verstehe ehrlich gesagt dein Problem gar nicht, skullyan.

Du fängst erstmal damit an eine Schleife zu schreiben, die Fibonnaci-Zahlen generiert, meinetwegen zu anfang noch eine Endlosschleife.
Dann definierst du für diese Schleife eine passende Abbruchbedinung, welche in diesem Fall einfach wäre, dass die aktuelle Fibonacci-Zahl kleiner als 4000000 sein muss.
Der nächste Schritt ist herauszufinden, ob die aktuelle Zahl gerade oder ungerade ist, dazu bietet sich der modulo-Operator an.
Und schließlich brauchst du nur noch eine Summe, aller geraden Fibonnaci-Zahlen zu bilden.

Bei welchem dieser Schritte hast du ein Problem?

...

Hallo,

am besten du machst schonmal aus deiner for-Schleife eine while-Schleife.
Dann kann auch der Abschnitt weg:

if (p > MAX || k > MAX || s > MAX) 
            break;

und schau dir noch einmal diesen Abschnitt an:

if(p % 2 == 0) 
        help += p; 
        if(k % 2 == 0) 
        help += k;        
        if(s % 2 == 0) 
        help += s;

Werner Salomon

skullyan schrieb:

Wir haben die Aufgabe, alle geraden Fibonacci Zahlen zu summieren, die nicht größer als 4000000 sind und den Wert dann auszugeben.

ja das schreit doch geradezu nach einer abgefahrenen Lösung:

#include <algorithm> // find_if
#include <iostream>
#include <numeric> // accumulate
#include <boost/iterator/iterator_adaptor.hpp>
#include <boost/iterator/filter_iterator.hpp> // make_filter_iterator
#include <boost/lambda/lambda.hpp>

template< typename T >
class Fibonacci : public boost::iterator_adaptor< Fibonacci< T >, T, const T, boost::forward_traversal_tag, T >
{
public:
    explicit Fibonacci( const T& x = T(0), const T& prev = T(1) )
        : iterator_adaptor_( x ), m_prev( prev ) {}
    void increment()
    {
        const T fibo = base() + m_prev;
        m_prev = base();
        base_reference() = fibo;
    }
    T dereference() const { return base(); }
    static Fibonacci infinite() { return Fibonacci( T(-1), T(0) ); }
private:
    T m_prev;
};

int main()
{
    using namespace std;
    using namespace boost::lambda;
    const int N = 4000000;
    const Fibonacci< int > last = find_if( Fibonacci< int >(), Fibonacci< int >::infinite(), _1 > N );
    cout << "Die Summer aller geraden Fibonacci-Zahlen unter " << N << " ist " 
        << accumulate(  boost::make_filter_iterator( _1 % 2 == 0, Fibonacci< int >(), last ), 
                        boost::make_filter_iterator( _1 % 2 == 0, last,               last ), 0 ) << endl;
    return 0;
}

Gruß
Werner

freaky

Werner Salomon mit seinen ownage Lösungen

skullyan

_) schrieb:

Hallo,

am besten du machst schonmal aus deiner for-Schleife eine while-Schleife.
Dann kann auch der Abschnitt weg:
if (p > MAX || k > MAX || s > MAX) 
            break;
und schau dir noch einmal diesen Abschnitt an:
if(p % 2 == 0) 
        help += p; 
        if(k % 2 == 0) 
        help += k;        
        if(s % 2 == 0) 
        help += s;

Was soll daran falsch sein?

Anscheinend reicht das hier:

help += p;

Nexus

skullyan schrieb:

Nexus schrieb:

Du würdest bei dem Code schon viel mehr durchblicken, wenn du statt s, k und p sinnvolle Bezeichner nehmen und deinen Code in Funktionen aufteilen würdest. Konsistente Einrückung wäre auch eine Idee.

Stimmt, aber wie schaut denn jetzt die Lösung aus?

Ziemlich schlechte Antwort.

skullyan schrieb:

Das bringt mir jetzt herzlich wenig, aber naja... Dann werde ich es wohl aufgeben müssen.

Dann gib eben auf, wenn du nicht selbst nachdenken willst. Glaube aber nicht, dass du so Mitleid erregst.

skullyan

1089154 ist mein Ergebnis. Stimmt das?

Dravere

Werner Salomon schrieb:

ja das schreit doch geradezu nach einer abgefahrenen Lösung:

Stimmt, aber ich hätte jetzt eher zu sowas tendiert:

#include <cstddef>
#include <iostream>

template<std::size_t N>
struct Fibonacci
{
    static std::size_t const RESULT = Fibonacci<N - 2>::RESULT + Fibonacci<N - 1>::RESULT;
};

template<>
struct Fibonacci<0>
{
    static std::size_t const RESULT = 0;
};

template<>
struct Fibonacci<1>
{
    static std::size_t const RESULT = 1;
};

template<bool CHECK, std::size_t N, std::size_t MAX_FIBONACCI>
struct SumEvenFibonacciHelper
{
private:
    static std::size_t const FIBONACCI = Fibonacci<N>::RESULT;
    static std::size_t const NEXT_SUM = SumEvenFibonacciHelper<(FIBONACCI < MAX_FIBONACCI), N + 1, MAX_FIBONACCI>::RESULT;

public:
    static std::size_t const RESULT = NEXT_SUM + (FIBONACCI & 1 ? 0 : FIBONACCI);
};

template<std::size_t N, std::size_t MAX_FIBONACCI>
struct SumEvenFibonacciHelper<false, N, MAX_FIBONACCI>
{
    static std::size_t const RESULT = 0;
};

template<std::size_t MAX_FIBONACCI>
struct SumEvenFibonacci
{
    static std::size_t const RESULT = SumEvenFibonacciHelper<true, 2, MAX_FIBONACCI>::RESULT;
};

int main() 
{
    std::cout << SumEvenFibonacci<4000000>::RESULT << std::endl;

    return 0; 
}

Grüssli

Dravere

skullyan schrieb:

1089154 ist mein Ergebnis. Stimmt das?

Meine Lösung und die von Werner ergeben 4613732.

Grüssli

skullyan

Dravere schrieb:

skullyan schrieb:

1089154 ist mein Ergebnis. Stimmt das?

Meine Lösung und die von Werner ergeben 4613732.

Grüssli

skullyan schrieb:

Dravere schrieb:

skullyan schrieb:

1089154 ist mein Ergebnis. Stimmt das?

Meine Lösung und die von Werner ergeben 4613732.

Grüssli

Jetzt hast du das Ergebnis, aber den Weg nicht... hat's sich für dich gelohnt?

otze

gelöscht

knivil

Da keine explizite Programmiersprache angegeben ist, und es bestimmt nur zufaellig in das C++-Forum gerutscht ist, poste ich mal meine Loesung in Haskell:

fibs = 0 : 1 : zipWith (+) fibs (tail fibs)
main = do putStrLn $ show $ sum $ takeWhile (<4000000) $ filter even fibs

Bashar

Und gerade wollte ich fragen, wo knivil mit seinem Haskell-Einzeiler bleibt.

volkard

Hach, sowas wollte ich schon immer mal schreiben. (riecht fast ein wenig undefiniert?)

#include <iostream>
int main(){int a=1,b=2,s=2;while((b=(a+=b*2)*2-b)<4e6)s+=b;std::cout<<s;}

camper

volkard schrieb:

Hach, sowas wollte ich schon immer mal schreiben. (riecht fast ein wenig undefiniert?)
#include <iostream>
int main(){int a=1,b=2,s=2;while((b=(a+=b*2)*2-b)<4e6)s+=b;std::cout<<s;}

Ich seh nichts undefiniertes.

Werner Salomon

@Dravere, knivil, volkard

volkard Du inspirierst mich. Als Freund und Förderer der for-Schleife würde ich schreiben:

#include <iostream>
#include <algorithm> // std::swap

int main()
{
    int sum = 0;
    for( int prev_even = 0, fibo_even = 2; fibo_even < 4E6; std::swap( prev_even += 4*fibo_even, fibo_even ) )
        sum += fibo_even;
    std::cout << sum << std::endl;
}

Gruß
Werner

SeppJ

Hier dann noch eine für die Sprache C typische Version :

#include <stdio.h>

I_I(_, _0_, __,_3)??<return((_=(_0_+=_*_3)*_3-_)<4e6)?I_I(_,_0_,__+=_,_3):__;??>main(_)??<printf("%i",I_I(_+_,_,_+_,_+_));??>