3. Brauche Hilfe für folgende Übung

Brauche Hilfe für folgende Übung

  • ?

    Werner Salomon schrieb:

    ...und endet nach heutigen Kenntnisstand immer mit einer 1. ...

    Man vermutet es endet immer mit der Folge 4,2,1. Der Beweis fehlt noch. Bei Fermat vermutete man zuerst auch - erst nachdem der Beweis nun da ist kann man sagen man weiß es tut immer so wie vermutet. Es sei denn man ist Anhänger von Popper ... 🙂

    Werner Salomon schrieb:

    Zudem ist sie ein schönes Beispiel für die Anwendung des boost.iterator_adaptors wie folgender Code zeigt:

    Nein ist es nicht und nein zeigt er nicht. 😃

    SeppJ schrieb:

    Da das aktuelle Glied nur vom Vorgänger abhängt, reicht es, auf 1 zu prüfen, denn wenn man erstmal bei der 1 ist, kommt danach immer 4,2,1.

    Wie oben bereits erwähnt musst du bei Prüfung auf 1 anschließend nochmal prüfen ob die 4 und die 2 bereits aufgetaucht sind und du es nicht z.B. mit einem Startwert von 1 oder 2 zu tun hattest. Die Folge 4,2,1 soll ja nur 1 Mal auftauchen. Prüfen auf 4 tut es bzw. prüfen auf 1 mit der Bedingung k>1.

    Nebenbei, so wie dieser Hausaufgabe-Thread abgelaufen ist, wage ich mal zu bezweifeln, dass das irgendjemandem geholfen hat. 😉

    0
  • U

    Mitleid schrieb:

    Nebenbei, so wie dieser Hausaufgabe-Thread abgelaufen ist, wage ich mal zu bezweifeln, dass das irgendjemandem geholfen hat. 😉

    Also ich denke, mein Code ist verständlich genug, um ihm zu helfen 😛
    Und wenn er(sie?^^) dann noch die Kommentare zur Abbruchbedingung(von SeppJ etc) liest, sollte er es auch allein hinbekommen, wenn er zumindest den Willen hat, was zu verstehen...

    bb

    0
  • ?

    @unskilled
    Ich glaube ja es handelt sich bei Aleph1 weder um einen Er noch um eine Sie sondern um einen SpamBot. 😃

    Dennoch. Ob jemand, der noch nicht einmal eine Zuweisung hinbekommen hat deinen Code (Funktionen, Arrays, Zeiger) verstehen wird ist fraglich. Selbst wenn, hast du ihn nicht motiviert sich mit der Aufgabe auseinanderzusetzen, indem du die Lösung lieferst.

    Ich kann ja verstehen warum manche Verzweifelte hier, kurz vor Abgabeschluß, ihre Hausaufgabe einstellen. Dennoch tut man ihnen keinen Gefallen wenn man ihnen die Arbeit abnimmt.

    Möglicherweise bekommt Aleph1 jetzt die Punkte für die Aufgabe, gelernt hat er jedoch nichts.

    Und wenn dann noch falsche Behauptungen gepostet werden, oder Beiträge nach dem Motto "Seht her, was ich alles kann!", dann kostet das den Hilfesuchenden auch noch kostbare Zeit. Irgendwo muss man ja auch verantwortlich handeln.

    P.S.: Wenn hier allerdings einer schreibt er braucht c++ nur für diese eine Aufgabe und sonst nie mehr, oder wenn es an dieser Aufgabe hängt, ob ein ganzes Semester den Bach runter geht, dann hätte ich (etwas Langeweile vorausgesetzt) auch keine Probleme damit eine Lösung hinzuschreiben.

    0
  • A

    Ihr verwirrt mich alle:

    So ich habe es jetzt soweit:

    #include<iostream>
using namespace std;

int main()
{
int x=27;
int k=0;

if (x >= 0)
{
while(k<9)
{
cout << x << endl;
x=3*x+1;

if(k%2 != 0)
{
x=3*x+1;
}
else{
     x=x/2; 
}
k++;

}
}
}

}

    Ist das so in Ordnung?

    0
  • _

    Unabhängig vom Problem solltest du dringend an deiner Einrückung arbeiten. So wirst du schnell die Übersicht verlieren (wenn nicht schon geschehen 😉 )...

    0
  • K

    Diese Folge ist die sogenannte Collatz-Folge und endet nach heutigen Kenntnisstand immer mit einer 1.

    Kannst du bitte eine Quelle angeben, wo dein immer bewiesen ist. Ansonsten ist der Kenntnisstand: Wir wissen es nicht.

    Ausserdem wird es doch erst interessant, wenn man einige Probleme loesen kann. Z.b. welches n<10^8 generiert die laengste Sequenz? Kann diese Frage dein Iterator beantworten?

    0
  • V

    Werner Salomon schrieb:

    #include <algorithm> // copy
#include <iterator> // ostream_iterator
#include <iostream>
#include <boost/iterator/iterator_adaptor.hpp>

template< typename T >
class basic_collatz : public boost::iterator_adaptor< basic_collatz< T >, T, T, boost::forward_traversal_tag, const T >
{
public:
    explicit basic_collatz( const T& x )
        : iterator_adaptor( x )
    {}
    void increment()
    {
        if( base_reference() % 2 == 0 )
            base_reference() /= 2;
        else
            ++( base_reference() *= 3 );
    }
    T dereference() const { return base_reference(); }
};
typedef basic_collatz< int > Collatz;

int main()
{
    using namespace std;
    for( int x; cout << "> ", cin >> x && x > 0; )
    {
        copy( Collatz( x ), Collatz( 1 ), ostream_iterator< int >( cout << "Collatz-Folge: ", " " ) );
        cout << endl;
    }
    return 0;
}

    Deine Codebeispiele als humoreske Einlagen sind immer wieder lesenswert.

    Werner Salomon schrieb:

    Zudem ist sie ein schönes Beispiel für die Anwendung des boost.iterator_adaptors wie folgender Code zeigt:

    Aber hier tust Du so, als sei es anständig, schön oder empfehlenswert, sowas zu machen. Das bestreite ich.

    0
  • U

    Aleph1 schrieb:

    Ihr verwirrt mich alle:

    So ich habe es jetzt soweit:

    wie gesagt - das nächste mal bitte einrücken...

    hier mal richtig eingerückt:

    #include<iostream>
using namespace std;

int main()
{
  int x=27;
  int k=0;

  if (x >= 0) //unnötig, wird in der aufgabenstellung als gegeben vorrausgesetzt
  {
    while(k<9) //steht doch nirgendwo in der aufgabenstellung!? wieso tust du das?
    {
      cout << x << endl;
      x=3*x+1; //was willst du hier machen?

      if(k%2 != 0)
      {
        x=3*x+1;
      }
      else
      {
        x=x/2; 
      }
      k++;
    }
  }
}

} //oh, hier ist ja ne klammer zu viel...

    Ist das so in Ordnung?

    Wie du siehst - nein...
    Du solltest eben nicht einfach nur meinen Code reinkopieren sondern die Kommentare durchlesen und ihn verstehen...

    Jetzt zeig doch wenigsten mal ein wenig Initiative und beantworte mir die beiden Fragen im Quelltext.
    Und dann versuchst du mal selbst, was sinnvolles zu fabrizieren...

    bb

    0
  • ?

    Aleph1 schrieb:

    Ist das so in Ordnung?

    Nein, ist es noch nicht. Aber, du kommst der Sache näher.

    Entferne die zusätzliche Zuweisung und ändere die Abbruchbedingung der while-Schleife so, dass sie den allgemeinen Fall erfasst und nicht nur den Fall x0=27 aus der Aufgabenstellung. Außerdem würde ich in der Ausgabe das k noch mit reinnehmen. So ungefähr:

    cout << "X" << k << " = " << x << endl;
    0
  • W

    knivil schrieb:

    Diese Folge ist die sogenannte Collatz-Folge und endet nach heutigen Kenntnisstand immer mit einer 1.

    Kannst du bitte eine Quelle angeben, wo dein immer bewiesen ist. Ansonsten ist der Kenntnisstand: Wir wissen es nicht.

    Ich hatte mich ungenau ausgedrückt. Ich meinte natürlich, dass bis heute keine natürliche Zahl bekannt ist, bei der die Collatz-Folge nicht in 4,2,1 mündet. Da schon viele Leute mit viel PC-Power danach gesucht haben, kann man sicher annehmen, dass es für alle Werte gilt, die auf einem normalen PC in ein int passen. Wer da genaueres wissen möchte, folge dem Link oben.

    knivil schrieb:

    Ausserdem wird es doch erst interessant, wenn man einige Probleme loesen kann. Z.b. welches n<10^8 generiert die laengste Sequenz? Kann diese Frage dein Iterator beantworten?

    nun, da es praktisch ein Iterator im Sinne des C++-Standards ist, kann man natürlich mit Hilfe der Algorithmen und boost.bind ...

    #include <algorithm> // copy, max_element
#include <iostream>
#include <boost/iterator/iterator_adaptor.hpp>
#include <boost/iterator/counting_iterator.hpp>
#include <boost/bind.hpp>

typedef basic_collatz< int > Collatz; // basic_collatz< int > s.o.

Collatz makeCollatz( int x ) { return Collatz( x ); } // kein bind für Konstruktor

int main()
{
    using namespace std;
    cout << "Bitte Obergrenze fuer die Suche nach der laengsten Collatz-Folge angeben" << endl;
    int n;
    if( cin >> n )
    {
        cout << *max_element( boost::counting_iterator< int >( 1 ), boost::counting_iterator< int >( n+1 ),
            boost::bind( &distance< Collatz >, boost::bind( &makeCollatz, _1 ), Collatz( 1 ) )
            < boost::bind( &distance< Collatz >, boost::bind( &makeCollatz, _2 ), Collatz( 1 ) )
            ) << " liefert die laengste Folge im Interval [1," << n << "]" << endl;
    }
    return 0;
}

    Ich nehme an, dass Volkard das wieder lustig findet - aber warum nicht. 😉

    Die Ausgabe ist z.B.:

    Bitte Obergrenze fuer die Suche nach der laengsten Collatz-Folge angeben
1000
871 liefert die laengste Folge im Interval [1,1000]

    Natürlich ist das nicht die performanteste Lösung, aber das war auch nicht die Frage. Ich habe auch einen (sehr) performaten Ansatz mit ähnlicher Vorgehensweise, aber den traue ich mich nicht mehr zu posten - sonst erschlägt 's Volkard.

    Gruß
    Werner

    0
Anmelden zum Antworten