|
|
|
|
|
|
|
| | Zitat von b4ckspin
hab die Sachen mal geändert und versucht die Methode Fakultaet anzupassen -> http://pastebin.com/vTNhf37j
ist das auch richtig ( iterativ halt.. ) auch wie die Zeitmessung eingebaut ist?
| |
Zur Zeitmessung: Am Anfang jeder Methode misst du die Zeit, am Ende nochmal und schreibst die Differenz vor dem return (bei den rekursiven Varianten musst du deshalb eine weitere Variable nutzen, um keinen rekursiven Aufruf im return zu haben) in eine Klassenvariable. getLastRuntime() gibt dann nur diese Variable zurück und wird in keiner anderen Methode aufgerufen!
Dein Algorithmus liefert für n=0 oder 1 ein falsches Ergebnis, die Fälle (zumindest einen davon) musst du gesondert behandeln.
|
|
[Dieser Beitrag wurde 2 mal editiert; zum letzten Mal von Redh3ad am 22.01.2013 20:46]
|
|
|
|
|
|
|
|
|
| | Zitat von Redh3ad
Dein Algorithmus liefert für n=0 oder 1 ein falsches Ergebnis, die Fälle (zumindest einen davon) musst du gesondert behandeln.
| |
Tut er nicht. 0! = 1! = 1
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
ok nochmal drüber gegangen.
kanns sein das wenn ich n = 10000000 nehme die Berechnungen der Folgen nur (iterativ)222 ms und (rekursiv)141 ms brauchen? ..
|
|
|
|
|
|
|
|
|
|
|
|
Um 10000000! darzustellen hat dein Computer nicht genug Arbeitsspeicher, das ist also eher unwahrscheinlich.
|
|
|
|
|
|
|
|
|
|
|
|
Ne, bei der Rekursion muss was falsch sein.
|
|
|
|
|
|
|
|
|
|
|
| | Zitat von Danzelot
Um 10000000! darzustellen hat dein Computer nicht genug Arbeitsspeicher, das ist also eher unwahrscheinlich.
| |
Da long oder int immer wieder überläuft ist das kein Problem. :P
|
|
|
|
|
|
|
|
|
|
|
|
Wenn du fertig bist und dir langweilig ist, überleg dir noch warum deine aktuelle Formulierung von "FibonacciRekursiv" recht ungeschickt ist und wie mans schlauer (heißt viel viel effizienter) hinschreiben könnte.
|
|
|
|
|
|
|
|
|
|
|
| | Zitat von con_chulio
schon mal jemand einen Vortrag für schüler gehalten (11te Klasse Gymnasium)
Muss nächste Woche Dienstag 4 h mit denen verbringen. 2h vortrag, 2h praktikum(also grob, sind natürlich pause etc. pp. mit drinnen)
irgenjemand sowas schonmal gemacht und kann ein paar tips aus erster Hand mitgeben?
Oder allgmein Erfarhungen, Ängste, Wünsche, Tips, etc. pp.
Kann evtl. auch die Folien hochladen wenn ich sie endlich mal fertig habe....
| |
Es ist zwar eine 11te Klasse, aber glaub ja nicht, das sich alle benehmen können. Niemand wird dir über 2h die volle Aufmerksamkeit schenken. Du hast auch keinen Lehrauftrag. Es muss nicht jeder Schüler hinterher alles verstanden haben. Du kannst froh sein, wenn die zwei, drei Genies in der Klasse dir gespannt folgen.
Wenn das Praktikum am Rechner ist: Gib ihnen die Aufgabenstellung vorher. Bildschirme haben eine magische Wirkung auf Menschen. Selbst Rechner mit ausgeschalteten Schirmen sind anziehend. Du kannst es vergessen im Rechnerraum wichtige Ansagen zu machen.
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
| |
| Code: |
int myArray[5] = {0, 1, 2, 3, 4};
int *myTuet = myArray;
cout << "1: " << *myTuet<< "\n" << "2: " << *myTuet++;
|
|
Was wird ausgegeben und warum?
|
|
[Dieser Beitrag wurde 1 mal editiert; zum letzten Mal von Gore am 22.01.2013 21:05]
|
|
|
|
|
|
|
|
| | Zitat von B0rG*
überleg dir noch ... wie mans schlauer (heißt viel viel effizienter) hinschreiben könnte.
| |
Die Lernkurve von "ich steck mal 100000000000 rein" zu "so ginge das effizienter" wäre beachtlich. 
|
|
|
|
|
|
|
|
|
|
|
|
Es ist nie zu früh rekursives Denken zu lernen.
|
|
|
|
|
|
|
|
|
|
|
| | Zitat von cms
| | Zitat von Danzelot
Um 10000000! darzustellen hat dein Computer nicht genug Arbeitsspeicher, das ist also eher unwahrscheinlich.
| |
Da long oder int immer wieder überläuft ist das kein Problem. :P
| |
Außerdem ist mir aufgefallen dass 10000000! schon in ungefähr 218 Millionen Binärstellen darstellbar ist, das passt also doch in handelsübliche Mengen Arbeitsspeicher 
| | Zitat von Gore
| |
| Code: |
int myArray[5] = {0, 1, 2, 3, 4};
int *myTuet = myArray;
cout << "1: " << *myTuet<< "\n" << "2: " << *myTuet++;
|
|
Was wird ausgegeben und warum?
| |
Beide Male 0, oder verwechsle ich gerade die Dereferenzierung? Alternativ zwei Mal die Speicheradresse von myTuet.
|
|
[Dieser Beitrag wurde 1 mal editiert; zum letzten Mal von Danzelot am 22.01.2013 21:09]
|
|
|
|
|
|
|
|
|
| | Zitat von Gore
| |
| Code: |
int myArray[5] = {0, 1, 2, 3, 4};
int *myTuet = myArray;
cout << "1: " << *myTuet<< "\n" << "2: " << *myTuet++;
|
|
Was wird ausgegeben und warum?
| |
Ich suche verzweifelt die Falle dabei, aber was spricht gegen
1: 0
2: 1
|
|
|
|
|
|
|
|
|
|
|
Hmm wird cout von rechts nach links ausgewertet?
Bekomme zweimal eine 1
|
|
|
|
|
|
|
|
|
|
|
| | Zitat von Rufus
| | Zitat von Gore
| |
| Code: |
int myArray[5] = {0, 1, 2, 3, 4};
int *myTuet = myArray;
cout << "1: " << *myTuet<< "\n" << "2: " << *myTuet++;
|
|
Was wird ausgegeben und warum?
| |
Ich suche verzweifelt die Falle dabei, aber was spricht gegen
1: 0
2: 1
| |
Dachte ich auch, hab mich aber nich getraut zu posten
@Gore
versuchs mal mit ++*myTuet;
oder geht das syntaktisch nicht?
|
|
[Dieser Beitrag wurde 1 mal editiert; zum letzten Mal von caschta am 22.01.2013 21:13]
|
|
|
|
|
|
|
|
|
| | Zitat von caschta
| | Zitat von Rufus
| | Zitat von Gore
| |
| Code: |
int myArray[5] = {0, 1, 2, 3, 4};
int *myTuet = myArray;
cout << "1: " << *myTuet<< "\n" << "2: " << *myTuet++;
|
|
Was wird ausgegeben und warum?
| |
Ich suche verzweifelt die Falle dabei, aber was spricht gegen
1: 0
2: 1
| |
Dachte ich auch, hab mich aber nich getraut zu posten
| |
Post/Preincrement
|
|
|
|
|
|
|
|
|
|
|
| | Zitat von Gore
Hmm wird cout von rechts nach links ausgewertet?
Bekomme zweimal eine 1
| |
Klingt jetzt nicht logisch. myTuet++ gibt den Wert vor der Inkrementierung zurück -> Bei Auswertung von rechts nach links müsste 1 und 0 ausgegeben werden, von links nach rechts beide Male 0, oder?
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
| | Zitat von Danzelot
von links nach rechts beide Male 0, oder?
| |
links -> rechts
Falls *myTuet++ = (*myTuet)++ dann 0/0
Falls *myTuet++ = *(myTuet++) dann 0/1
rechts -> links
Falls *myTuet++ = (*myTuet)++ dann 1/0
Falls *myTuet++ = *(myTuet++) dann 1/1
ooooder?
// wtf, okay @ link
|
|
[Dieser Beitrag wurde 1 mal editiert; zum letzten Mal von Rufus am 22.01.2013 21:19]
|
|
|
|
|
|
|
|
|
|
Der Compiler kann auch bei Funktionsaufrufen die Evaluation der Parameter unabhängig von ihrer Reihenfolge festlegen.
|
|
|
|
|
|
|
|
|
|
|
| | Zitat von Rufus
| | Zitat von Danzelot
von links nach rechts beide Male 0, oder?
| |
links -> rechts
Falls *myTuet++ = (*myTuet)++ dann 0/0
Falls *myTuet++ = *(myTuet++) dann 0/1
rechts -> links
Falls *myTuet++ = (*myTuet)++ dann 1/0
Falls *myTuet++ = *(myTuet++) dann 1/1
ooooder?
// wtf, okay @ link
| |
| |
| Code: |
int *myTuet2 = myArray;
int a = *myTuet2;
int b = *++myTuet2;
cout << "1: " << a << "\n" << "2: " << b;
|
|
Das tut wie erwartet
|
|
|
|
|
|
|
|
|
|
|
| | Zitat von Oli
| | Zitat von horscht(i)
Wenn du Ge/Si simulieren würdest, würde ich sagen, passt.
Pyramidale Quantenpunkte sind da keine Seltenheit.
Da du aber Si/Si machst, bin ich skeptisch.
| |
Ne, weiß und blau sind Ga und P.
/e: War aber noch ein Fehler im Programm.
| |
Sicher, dass es ein Fehler war? GaP auf Si kann auch unschöne Dinge tun.
Ich empfehle mal dieses Paper. Da wird relativ allgemeingültig die kritische Schichtdicke gegen die Verspannung hergeleitet. Evtl. hilft dir das einzuschätzen, ob es wirklich ein Programmfehler oder aber ein vernünftiges, aber unerwartetes, Resultat war.
|
|
|
|
|
|
|
|
|
|
|
| | Zitat von Gore
Das tut wie erwartet
| |
Ein Glück!
|
|
|
|
|
|
|
|
|
|
|
Oh Gott, Fehlerrechnung ist viel zu lange her
Ich hab hier zwei Messwerte  mit Unsicherheit  . Jetzt mach ich die Summe aus denen und teile durch Zwei. Was mach ich denn dann mit der Unsicherheit?
|
|
|
|
|
|
|
|
|
|
|
|
Gauß sagt die Unsicherheiten werden ebenfalls addiert und halbiert.
|
|
|
|
|
|
|
|
|
|
|
|
also bleibt er gleich? Aber irgendwann muss das doch statistische Vorteile haben mehr Messwerte aufzunehmen.
|
|
|
|
|
|
|
|
|
|
|
| | Zitat von RichterSkala
Oh Gott, Fehlerrechnung ist viel zu lange her
Ich hab hier zwei Messwerte mit Unsicherheit . Jetzt mach ich die Summe aus denen und teile durch Zwei. Was mach ich denn dann mit der Unsicherheit?
| |
Dann ist
|
|
|
|
|
|
|
|
|
|
|
Nehmen wir an ich habe einen Sensor, den ich X mal pro Sekunde abtasten kann und bei dem ich live rhythmische Peaks erkennen möchte und dann reagieren wenn sie fehlen.
Wertebereich des Sensors ist mir bekannt auch die ungefähre Frequenz der Peaks. Außerdem ist der Sensor noch ein wenig verrauscht.
Vorschläge und Methoden die ich verwenden könnte?
|
|
|
|
|
|
|
|
| Thema: pOT-lnformatiker, Mathematiker, Physiker XII ( Jetzt mit Primzahlen > 1024 ) |
