Brauche bitte dringend Hilfe für Klausur

[lowfyr]

Hallo, wollte mal kurz fragen ob hier jemand so nett ist und mir bei einem Problem helfen könnte.
Wir schreiben in wenigen Tagen eine Informatik Klausur und haben sozusagen schon eine Probearbeit bekommen. Es liegt nicht daran das ich zu faul bin sie zu machen, sondern daran unser Lehrer uns leider viel zu wenig darauf vorbereitet hat.
Es geht um die Mandelbrotmenge, imaginäre Zahlen etc.

Ich habe das Aufgabenblatt bei Rapidshare hochgeladen da es eine .pdf-Datei ist.


würde mich über Hilfen riesig freuen!

mfg

lowfyr

 

[nickname]

Hi,

ist denn die Aufgabe so umfangreich, dass es nicht möglich ist diese als Code hier reinzustellen?

Ich halte persönlich nichts davon mir irgendwelche Dateien runterzuladen. Geht nichts
gegen dich

gruß nickname

 

[javimka]

Wir machen keine Hausaufgaben. Würde dir auch nicht viel bringen, da schliesslich du die Klausur schreiben wirst. Wenn du bestimmte Frage hast und irgendwo nicht weiterkommst, helfen wir gerne.

 

[Spin]

Derzeit laden viele Benutzer Dateien herunter. Bitte versuchen Sie es in 2 Minuten noch einmal oder werden Sie Premium-Mitglied

Zeig doch mal her die Aufgaben , ich will datteln
Los jetzt ^^.

Also ich helfe gerne , wenn es für mich machbar ist :bae:

 

[javimka]

Hier: http://lantersoft.ch/download/100101Info12.pdf
Viel Spass

// EDIT:
Ich suche übrignes immer noch ein Programm, das mir die Sterne vom Himmel holt. Hat sich bisher auch noch keiner drum gekümmert, kannst es ja mal versuchen.

 

[eRaaaa]

// EDIT:
Ich suche übrignes immer noch ein Programm, das mir die Sterne vom Himmel holt. Hat sich bisher auch noch keiner drum gekümmert, kannst es ja mal versuchen.

Bitte:

    public static void main(String[] args) {
	Scanner sc = new Scanner(System.in);
	System.out.print("Wieviele Sterne sollen vom Himmel geholt werden?");
	int sterne = sc.nextInt();
	System.out.println("Bitte warten....hole " + sterne
		+ " Sterne vom Himmel!");
    }

:bae:

 

[lowfyr]

das "problem" ist es sind ja keine HAUSAUFGABEN, ich denke es werden genau diese aufgaben in der Klausur kommen..... der lehrer ist ein bisschen ... KOMISCH^^.
Bitte bitte bitte könnte wer, die für euch ja wohl sehr leichten fragen , beantworten. oder wenigstens im groben.

lg

lowfyr

 

[javimka]

@eRaaaa
Soweit so gut, vielen Dank. Werde ich gleich daran machen, die Dinger auszuknipsen. Wird ne Weile dauern, wegen der Integer Beschränking auf 2 Mrd, aber das wird schon...

@lowfyr
So juristisch genau geht es nicht darum, ob es eine Hausaufgabe, eine Klausur Aufgabe oder was auch immer ist. Wir lösen prinzipiell (alle ausser Spin) keine Aufgaben, für die du selbst nichts gemacht hast.

Übrigens steht auf Wikipedia zu Hausaufgaben:

Hausaufgaben (in Österreich Hausübungen) sind Pflichtübungen für Schüler außerhalb der Schulstunden. Sie werden in der Schule vom Lehrer als Ergänzung des Unterrichts aufgegeben und sollen in der Regel zu Hause erledigt werden. Im weiteren Sinne bezeichnet man als Hausaufgaben auch andere, berufliche oder freiwillig übernommene, selbstverantwortlich zu erledigende Verpflichtungen.

Also wirst du selbst ein paar Lösungsansätze erarbeiten müssen, oder auf die Gutmütigkeit von Spin hoffen.

 

[Spin]

So nun noch bischen denken und denn passts

/**
 *
 * @author Spin
 */

/* Klasse Übung*/
public class Übung {

    /**
     * Schau mal dein Lehrer hat dir schon alles vorgegeben:
     * startCR = -2 ; startCI = 1 ; breite = 2
     */
    /**
     * 
     * @param startCR - Parameter die übergeben werden :
     * @param startCI
     * @param breite
     */
    public void zeichneMandelbrotmenge(double startCR, double startCI, double breite) {
        // die übergebenden Werte zwischenspeichern
        double cR = startCR;  // hier ist : -2
        double cI = startCI;// hier ist : 1

        // von 0-399
        for (int i = 0; i < 400; i++) {
            // von 0-399
            for (int j = 0; j < 400; j++) {
                // lokale variablen initialisieren
                int k = 0;
                int betrag = 0;
                int zR = 0;
                int zI = 0;
                // solange betrag (hier: 0) kleiner 10
                // und k (hier:0) kleiner tiefe
                while ((betrag < 10) && (k < tiefe)) {
                    // quadriere
                    quadriereZ();
                    // addiere komplexe zahlen
                    addiereKomplexeZahlen();
                    // berechne betrag 
                    betragZ();
                    // am ende k erhöhen ( beim nächsten durchlauf ist somit k = 1)
                    k = k + 1;
                }
                   // wenn der wert k gleich dem wert tiefe ist:
                    if (k == tiefe) {
                        // dann den stift senken und zeichnen
                        t.senkeStift();

                    } else {
                        // wenn nicht , soll der stift eins vorgehen
                        t.vor(1);
                    }
                    // am ende der forschleife
                    // wird cR ( was ja -2 ist mit der 2/400 addiert)  // das für jeden durchlauf
                    // dadurch wird der Tintenfleck größer
                    cR = cR + breite / 400;
                }
                // für jedes i deiner äußeren forschleife:
                // drehe den stift um 180
                t.drehe(180);
                // gehe 400 vor
                t.vor(400);
                // drehe um -90
                t.drehe(-90);
                // gehe 1 vor
                t.vor(1);
                // drehe um -90
                t.drehe(-90);
                // setze CR Zurück auf -2
                cR = startCR;
                // und setze cI zurück
                cI = cI - breite / 400;
            }
        } // Methoden ende
    
    // Nun liegts an dir die Tabelle bis 3 auszufüllen
    /**
     * Mit Rekursionstiefe bezeichnet man die Verschachtelungstiefe rekursiver Aufrufe.
       Eine rekursive Prozedur ruft sich beim Ablauf selber auf, berechnet etwas, ruft sich wieder selber auf, berechnet etwas, 
     * ruft sich wieder selber auf usw. Die Anzahl, mit der sich die Funktion selber aufruft, wird als Rekursionstiefe bezeichnet.
     */
}