Was gibts da nicht zu verstehen. Damit dein Speicher nicht überläuft darfst du ein höchstens ein Rekursionslevel erreichen was von AutoIt vorgegeben ist. Das ist unterschiedlich bei x86 und x64 Systemen.
Das Problem bei dir ist, das er die Funktionen immer wieder und wieder called ohne sie vorher zu returnen, also pack das ganze lieber in eine Schleife mit einer Variable die bestimmt in welcher Funktion er laufen würde nur in der Schleife.
Wenn du deinen Code formatiert in einem Code-Tag posten würdest wäre das schonmal ein guter Anfang. Noch besser wäre wenn du nur die entsprechende Methode posten würdest.
ok denke habs verstanden nur eine Sache zur Sicherheit: Mit Return meinst du das Ende einer Func oder tatsächlich den Befehl?
Danke so oder so hat eig schon geholfen
Edit:@warfley sry bin überfordert nächstes mal bestimmt :X
Edit: achso quatsch stimmt ja, hab nach Kritik gefragt, alles ok^^
Du darfst die Funktionen nicht so oft callen. Löse das ganze lieber in einer Schleife mit einem Modusvariable und dann hast du auch keine Rekursion mehr.
Rekursion ist der immer wieder auftretende Aufruf einer Funktion mit einem eindeutigen Abbruchkriterium. Ohne Abbruchkriterium endet die Rekursionsschleife nie und dein Stack läuft irgendwann über.
Die Fakultät wird gerne als Beispiel dafür verwendet (auch wenn es verdammt ineffizient ist):
Code:
func nfac(n: Int) -> Int {
if n < 2 {
return 1
} else {
return n * nfac(n - 1)
}
}
Beim Aufruf nfac(3) wird die Abbruchbedingung nicht erfüllt, also erfolgt der Aufruf 3 * nfac(3 - 1).
Die Abbruchbedingung wird ebenfalls nicht erfüllt, also erfolgt 2 * nfac(2 - 1).
Jetzt wird die Abbruchbedingung erfüllt, also 1.
Ausgeschrieben sieht das so aus: nfac(3) = 3 * nfac(2), nfac(2) = 2 * nfac(1), nfac(1) = 1, also 3 * 2 * 1 = 6.
Dein Problem ist, dass die Folge der Funktionsaufrufe nie endet (da keine Abbruchbedingung vorhanden) und das kann selbst der stärkste Computer nicht auf Dauer durchhalten.
Wie findet man raus ob man rekursiv programmiert hat? Geh dein Script per Hand durch, wenn du aus _1() in jedem Fall _2() callest und in _2() in jedem Fall _1() callest ist das rekursiv.
Func _array1()
$PixelPosColor0 = PixelSearch(38 ,119 , 1615, 872, 0x412F4E, 1)
Select
Case IsArray($PixelPosColor0)
MouseClick("left", $PixelPosColor0[0], $PixelPosColor0[1], 1, 0)
Sleep(3000)
Start2()
Case Else
Do
Send("{Left down}")
Sleep(200)
Send("{Left up}")
Sleep(500)
Until IsArray($PixelPosColor0)
_array1()
EndSelect
EndFunc
Es scheint nie bis _array1() zu kommen aber hilft das ausreichend gegen Rekursion?
WTF? Das ist falsch auf allen möglichen ebenen
hier ist das mal sauber in Pseudo und normalen Tab abständen
Code:
Funktion Foo
PixelPosColor0 := PixelSearch(38 ,119 , 1615, 872, 0x412F4E, 1) //Startwert für die erste Überprüfung
While not IsArray(PixelPosColor0) //Kopfzeilige Schleife damit von Anfang an überprüft wird, und es keinen Ersten mindestdurchlauf gibt
Send("{Left down}")
Sleep(200)
Send("{Left up}")
Sleep(500)
PixelPosColor0 := PixelSearch(38 ,119 , 1615, 872, 0x412F4E, 1) //Neuen wert für nächste Überprüfung
// richtiger wert gefunden, geht weiter
MouseClick("left", $PixelPosColor0[0], $PixelPosColor0[1], 1, 0)
Sleep(3000)
Am besten ein Tipp, lösche mal deine Funktionen, denke drüber nach was du tuen willst, wie du es am besten Umsetzen könntest (male dir zur Not ein Diagramm) und fange nochmal von Vorn an
PS: und benutze mal bitte ordentliche Namen für deine Funktionen, jede Funktion soll ja was bestimmtes machen, benenne sie dann auch so (z.B. KlickeAufDenKopfVonDemTypenInDerMitteDesBildesFunk tion ist ein besserer Name als array1)
Und noch ein Tipp, verwende Rekrusionen nur wie Snow geschrieben hat,
Wenn Startwert dann gebe Startergebnis zurück, wenn nicht dann mache was rufe die funktion mit neuen Parametern erneut auf, so dass du auf jeden fall auf den Startwert kommst
Eine Funktion muss immer nach einer (beliebigen) endlichen anzahl an durchlaufen Terminieren.
PPS: Hier mal ein kurzer auszug aus wikipedia zur Definition eines Algorithmus:
Quote:
Aus dieser Definition sind folgende Eigenschaften eines Algorithmus ableitbar:
1. Das Verfahren muss in einem endlichen Text eindeutig beschreibbar sein (Finitheit).
2. Jeder Schritt des Verfahrens muss tatsächlich ausführbar sein (Ausführbarkeit).
3. Das Verfahren darf zu jedem Zeitpunkt nur endlich viel Speicherplatz benötigen (Dynamische Finitheit, siehe Platzkomplexität).
4. Das Verfahren darf nur endlich viele Schritte benötigen (Terminierung, siehe auch Zeitkomplexität).
Darüber hinaus wird der Begriff Algorithmus in praktischen Bereichen oft auf die folgenden Eigenschaften eingeschränkt:
1. Der Algorithmus muss bei denselben Voraussetzungen das gleiche Ergebnis liefern (Determiniertheit).
2. Die nächste anzuwendende Regel im Verfahren ist zu jedem Zeitpunkt eindeutig definiert (Determinismus).
Java Rekursion Primzahlen 12/01/2014 - Java - 6 Replies Hey könntest ihr mir helfen, wie ich rekursiv eine Primzahl bestimme?
// Implementieren Sie hier die Methode istPrim(n)
public static boolean ( int n) {
if (a%a-1==0) return false;
else return true;
könntet ihr mir helfen? Ich versuche gerade Java zu lernen..
Ich verstehe das nicht =o 09/21/2010 - Wolfteam - 7 Replies @dit
@dit: was ist 9:50 PM EST und unserer zeit?
Verstehe das net 01/12/2007 - WoW Bots - 10 Replies Hallo
Kann mir bitte wer erklären wie der Gilder geht?auf Ts
Ich versteh den treath net..
Danke
Meine icq:463674705 pls melden
Lasse mir noch belohnung einfallen^^
Mfg
