Beiträge von Mars

  • [close] AI Fight #1 - Snake

    Hab eine simple AI gebastelt. Allerdings hab ich ein Problem, manchmal wird einfach kein Futter auf der Karte gefunden.

    [autoit]

    Func _M_X(ByRef $aMap) ; Schauen wo sich das Futter befindet
    For $x = 1 To $AIFight_MapX Step 1
    For $y = 1 To $AIFight_MapY Step 1
    If $aMap[$x][$y] = $AIFight_MapFeed Then Return _M_A($x, $y)
    Next
    Next
    Return _M_A(-1, -1) ; Keins gefunden. Ohje !
    EndFunc
    Func _M_A($a, $b) ; Ziemlich verzwickte Methode um ein Array zu erzeugen
    Local $c[2] = [$a, $b]
    Return $c
    EndFunc

    [/autoit]

    Meistens bei der Generierung eines neuen Futterstücks. Dann ist teilweise ein bis zwei Runden kein Futter auf dem Feld. Ist das Absicht ?

    Edit: Einsendung ist raus, die Ausnahme wird intern behandelt.

    lg
    M

  • Regeln für den „AI Fight“ Wettbewerb

    Mein Vorschlag (wird aber etwas Zeit in Anspruch nehmen...): Das Elo-System.
    - Jeder "Spieler" bekommt zu Beginn 1000 Punkte (Startwert)
    - Eine Runde besteht aus n²-n Spielen. (Jeder gegen jeden)
    - Nach einer gewissen Anzahl Runden ist die Elo-Rangliste aussagekräftig. (Wie viele das sein werden weiß ich leider nicht. Vermutlich mehr als 5)

  • Achterrandom = 50

    Alina, ich verstehe dich nicht. Du möchtest "Zufällige" Zahlen. Ich hab natürlich nichts gegen AspirinJunkie, aber seine Funktion liefert im Regelfall hauptsächlich Einsen, das hat doch nix mit Zufällen zu tun.
    Dann wurde nie wirklich gesagt ob Zahlen nun einzeln, oder auch mehrfach vorkommen sollen. Wir haben hier einige interessante Beiträge mit einigen interessanten resultierenden Verteilungen gefunden. (Falls ich etwas vergessen habe bitte schreit mich an, Die BF Methode hab ich absichtlich nicht 10.000x laufen lassen, hab keine Jahrzehnte Zeit :P)

    Singe = Jede Zahl darf nur 1x vorkommen
    Multi = Jede Zahl darf beliebig oft vorkommen
    Micha_he - Der einzige der ne anständige (fast echte) Normalverteilung herzaubert (ist bei der Methode auch logisch)
    Chesstiger - Hier bekommt der "Zufall" direkt noch eine Packung Kreativität verabreicht :D
    AspirinJunkie - Klassischer Fall von 1/x² (oder sowas ähnliches)
    Mars (Single) - Sieht für mich nach einer halbwegs gelungenen halben Normalverteilung aus. (ich glaube, dass diese Verteilung charakteristisch für das gegebene Problem ist)
    Mars (Multi) - Auch irgendeine e Funktion

    Überlege mal welche Anforderungen du an die Verteilung stellst. Vorallem das mit den Doppelten und der verlangten "Zufälligkeit" ist interessant. Beispielsweise geben Micha_he und Chesstiger hauptsächlich 5,6,7,8,9,10,11 aus. Chesstiger hat es geschafft in diesem Bereich eine (bis auf den Zacken) Gleichverteilung hinzubekommen, Micha_he eine Normalverteilung gebastelt. AspirinJunkie's Methode liefert abfallende Zahlen mit fast 50% Einsen (im schnitt nach 10.000 Versuchen).
    [Blockierte Grafik: http://i.imgur.com/ixD9EOC.png]

  • Achterrandom = 50

    Hier nochmal eine Version mit Kontrolle auf doppelte Zahlen. Die Rechenzeit geht dadurch natürlich in die Höhe (liegt bei mir teils bei > 4 ms). Wenn etwas in der Ausgabe Rot ist heißt das, dass das Ergebnis unmöglich ist (z.B. 10 Zahlen jeweils größer als 5 mit der Summe 20) oder nicht genügend Rechenzeit verteilt wurde.
    Bei der "Zufälligkeit" von nichtdoppelten Zahlen gibts aber ein wichtiges Problem zu beachten. Wenn [Anzahl Zahlen] * [Mindestwert] in etwa im Bereich der [Summe] liegt existiert keine zufälligkeit. Extremfall ist z.B. 2,3,4. 3 Zahlen mit der Summe 9. Dafür gibt es nur eine Lösung wenn doppelte verboten sind -> Kein Zufall !

    Spoiler anzeigen
    [autoit]

    ConsoleWrite(@CRLF)
    For $i = 0 To 9 Step 1
    Test(Random(1, 7, 1), Random(80, 150, 1), Random(5, 10, 1))
    Next

    [/autoit] [autoit][/autoit] [autoit]

    Func Test($iMin, $iSum, $nCount, $iCalcTime = 50)
    Local $a, $c, $e, $u
    $a = RandomN($iMin, $iSum, $nCount, $iCalcTime, False)
    $c = @extended
    $e = @error
    $u = UBound($a)
    ConsoleWrite(($e ? '!' : '+') & ' Benötigte Zeit: ' & Round($c, 0) & ' µs' & @CRLF & ($e ? '!' : '+') & ' Mindestwert: ' & $iMin & @CRLF & ($e ? '!' : '+') & ' Anzahl Zahlen: ' & UBound($a) & @CRLF & ($e ? '!' : '+') & ' Summe: ' & Sum($a) & ' (sollwert: ' & $iSum & ')' & @CRLF & ($e ? '!' : '+') & ' ')
    For $i = 0 To UBound($a) - 1 Step 1
    ConsoleWrite($a[$i] & ($i = $u - 1 ? '' : ','))
    Next
    ConsoleWrite(@CRLF & @CRLF)
    EndFunc

    [/autoit] [autoit][/autoit] [autoit]

    ; ------------------------------------------------------------------------------------------------------------------------------------------------
    ; iMin - Mindestwert (dieser Wert wird bei den ausgegebenen Zahlen nicht unterschritten)
    ; iSum - Summe aller Zufallszahlen
    ; nCount - Anzahl der Zufallszahlen
    ; iCalcTime - Gestattete Rechenzeit (im Prinzip nur vorhanden, damit es sich nicht festfrisst falls ein unmögliches Ergebnis verlangt wird) MILLIsekunden !
    ; bMulti - True - Mehrfaches Vorkommen von Zahlen ist erlaubt
    ; | False - Mehrfaches Vorkommen ist verboten
    ; @error - 0 - Alles ok
    ; | 1 - Es konnte kein Ergebnis gefunden werden. Das kann entweder daran liegen,
    ; dass die Anzahl Runden unzureichend war (einfach runden erhöhen), oder
    ; das geforderte Ergebnis ist unmöglich. z.B. 10 Zahlen mit der Mindestgröße
    ; 5 die eine Summe von 20 ergeben. -> In dem Fall überlegen was man will.
    ; @extended - Beinhaltet grundsätzlich die benötigte Rechenzeit in µs (obacht, KEINE Millisekunden)
    ; ------------------------------------------------------------------------------------------------------------------------------------------------
    Func RandomN($iMin, $iSum, $nCount, $iCalcTime = 5, $bMultiple = False)
    Local $t = TimerInit(), $aRND[$nCount], $r, $nTMP, $s
    For $i = 0 To $nCount - 1 Step 1
    $aRND[$i] = $iSum
    Next
    $s = Sum($aRND)
    If $bMultiple = True Then
    While $s <> $iSum And TimerDiff($t) < $iCalcTime
    $r = Random(0, $nCount - 1, 1)
    If $s < $iSum Then
    $aRND[$r] = Round($aRND[$r] * Random(1, 2), 0)
    Else
    $nTMP = Round($aRND[$r] / Random(1, 2), 0)
    If $nTMP > $iMin Then $aRND[$r] = $nTMP
    EndIf
    $s = Sum($aRND)
    WEnd
    Else
    While $s <> $iSum And TimerDiff($t) < $iCalcTime
    $r = Random(0, $nCount - 1, 1)
    If $s < $iSum Then
    $nTMP = Round($aRND[$r] * Random(1, 2), 0)
    If Not Contains($aRND, $nTMP) Then $aRND[$r] = $nTMP
    Else
    $nTMP = Round($aRND[$r] / Random(1, 2), 0)
    If $nTMP > $iMin And Not Contains($aRND, $nTMP) Then $aRND[$r] = $nTMP
    EndIf
    $s = Sum($aRND)
    WEnd
    EndIf
    If $s = $iSum Then Return SetExtended(Int(TimerDiff($t)*1000), $aRND)
    Return SetError(1, Int(TimerDiff($t)*1000), $aRND)
    EndFunc

    [/autoit] [autoit][/autoit] [autoit]

    Func Contains($a, $n)
    For $i = 0 To UBound($a) - 1 Step 1
    If $a[$i] = $n Then Return True
    Next
    Return False
    EndFunc

    [/autoit] [autoit][/autoit] [autoit]

    Func Sum($a)
    If Not IsArray($a) Then Return $a
    Local $s = $a[0]
    For $i = 1 To UBound($a) - 1 Step 1
    $s += $a[$i]
    Next
    Return $s
    EndFunc

    [/autoit]


    Edit: Hier nochmal die Verteilung für Min = 1, Sum = 250, Anzahl = 20
    [Blockierte Grafik: http://i.imgur.com/IfnGABU.png]
    Sieht eigentlich ganz passabel aus finde ich...

  • Achterrandom = 50

    Habe etwas gebastelt. Leider ist die Methode sehr ineffizient, war eben die erste die mir eingefallen ist :) Als Parameter hat man die Anzahl Zahlen sowie die gewünschte Summe und einen Mindestwert (z.B. 1).

    Edit: Im vergleich zu Brute Force ist sie schon schnell. Bei mir braucht sie meistens ca. 1 Millisekunde...

    Spoiler anzeigen
    [autoit]


    ConsoleWrite(@CRLF)
    For $i = 0 To 9 Step 1
    Test(Random(1, 7, 1), Random(80, 150, 1), Random(5, 10, 1), 200)
    Next

    [/autoit] [autoit][/autoit] [autoit]

    Func Test($iMin, $iSum, $nCount, $iMaxRounds = 100)
    Local $t, $timer, $a, $c, $e, $u
    $timer = TimerInit()
    $a = RandomN($iMin, $iSum, $nCount, $iMaxRounds)
    $c = @extended
    $e = @error
    $t = TimerDiff($timer)
    $u = UBound($a)
    ConsoleWrite(($e ? '!' : '+') & ' Benötigte Zeit: ' & Round($t * 1000, 0) & ' µs' & @CRLF & ($e ? '!' : '+') & ' Benötigte ' & _
    'Runden: ' & $c & @CRLF & ($e ? '!' : '+') & ' Mindestwert: ' & $iMin & @CRLF & ($e ? '!' : '+') & ' Anzahl Zahlen: ' & UBound _
    ($a) & @CRLF & ($e ? '!' : '+') & ' Summe: ' & Sum($a) & @CRLF & ($e ? '!' : '+') & ' ')
    For $i = 0 To UBound($a) - 1 Step 1
    ConsoleWrite($a[$i] & ($i = $u - 1 ? '' : ','))
    Next
    ConsoleWrite(@CRLF & @CRLF)
    EndFunc

    [/autoit] [autoit][/autoit] [autoit]

    ; iMin - Mindestwert (dieser Wert wird bei den ausgegebenen Zahlen nicht unterschritten)
    ; iSum - Summe aller Zufallszahlen
    ; nCount - Anzahl der Zufallszahlen
    ; iRounds - Anzahl Runden die berechnet wird. (nur vorhanden, damit es sich nicht festfrisst falls ein unmögliches Ergebnis verlangt wird)
    ; @error - 0 - Alles ok
    ; 1 - Es konnte kein Ergebnis gefunden werden. Das kann entweder daran liegen,
    ; dass die Anzahl Runden unzureichend war (einfach runden erhöhen), oder
    ; das geforderte Ergebnis ist unmöglich. z.B. 10 Zahlen mit der Mindestgröße
    ; 5 die eine Summe von 20 ergeben. -> In dem Fall überlegen was man will.
    ; @extended - Beinhaltet grundsätzlich die Anzahl Runden die zur Berechnung genutzt wurden.
    Func RandomN($iMin, $iSum, $nCount, $iMaxRounds = 100)
    Local $aRND[$nCount], $r, $nTMP, $s, $c = 0
    For $i = 0 To $nCount - 1 Step 1
    $aRND[$i] = $iSum
    Next
    $s = Sum($aRND)
    While $s <> $iSum And $c < $iMaxRounds
    $c += 1
    $r = Random(0, $nCount - 1, 1)
    If $s < $iSum Then
    $aRND[$r] = Round($aRND[$r] * Random(1, 2), 0)
    Else
    $nTMP = Round($aRND[$r] / Random(1, 2), 0)
    If $nTMP > $iMin Then $aRND[$r] = $nTMP
    EndIf
    $s = Sum($aRND)
    WEnd
    If $s = $iSum Then Return SetExtended($c, $aRND)
    Return SetError(1, $c, $aRND)
    EndFunc

    [/autoit] [autoit][/autoit] [autoit]

    Func Sum($a)
    If Not IsArray($a) Then Return $a
    Local $s = $a[0]
    For $i = 1 To UBound($a) - 1 Step 1
    $s += $a[$i]
    Next
    Return $s
    EndFunc

    [/autoit] [autoit][/autoit] [autoit][/autoit]

  • Wettbewerb (für Anfänger und Fortgeschrittene) ?

    Update im Startpost
    Anhand der Grafik von Post 16 sieht man, dass für 16x16 bei der M02 Methode auch 28 etwa die Mitte bildet. Ich denke dass ein Schnitt von 22 - 23 ohne BruteForce locker drin ist. M01 ist ziemlich billig vom Prinzip (Kontrolle unmittelbar benachbarter Felder ohne die damit verbundene Fläche + Wahl der häufigsten Angrenzungen), M02 benutzt exakt das gleiche Schema nur mit einem Schritt mehr.

    Edit: Das mit den 22-23 muss ich wohl zurücknehmen. Habe festgestellt, dass es ein ziemlicher Akt ist so viel herauszuholen. Die Beispielfunktionen sollte man dennoch schlagen können. Hier ein paar 10er Mittelwerte von M03 :) 27.1|25.4|26.7|25.1|26.7|26.1|26.6|26.4|26.2|25.6|26.0|26.5|25.8|25.2|25.5 (wobei angemerkt werden muss, dass die Funktion die Zeitbeschränkung nicht einhält)

  • Wettbewerb (für Anfänger und Fortgeschrittene) ?

    Das ist immer das gleiche Problem, wenn man mit Zufällen arbeitet, je größer die Stichprobe, desto besser das Ergebnis.
    Ich habe mir überlegt immer 10 Versuche (je mehr, desto besser das Ergebnis) zusammenzufassen und den Mittelwert als 1 Versuch zu zählen. (ändert nichts am Ergebnis, aber die Kurve sieht wesentlich schöner aus).

    Das Problem ist: Angenommen ich nehme 100 zufällig erstellte Rätsel und reiche sie an alle Algorithmen weiter, dann wird es definitiv einen Gewinner geben. Allerdings wäre ein anderer Algorithmus bei anderen 100 Versuchen eventuell der beste. Vorallem ist der Mittelwert absolut nicht aussagekräftig. Im 1 Sigma intervall befindet sich nur zu 68% Wahrscheinlichkeit der tatsächliche Mittelwert. Wenn also Algo1 25.6 (+-3) und Algo2 26.5 (+-3.8) haben ist Algo1 nur mit einer gewissen wahrscheinlichkeit besser. (liegt nahe an 50% bei den Werten) Man kann also keinen Sieger bestimmen. Daher werde ich den PC bei einem Kopf an Kopfrennen wohl einfach mal ein paar (zehn)tausender berechnen lassen, anschließend sollte die Standardabweichung so klein sein, dass ein Sieger bestimmt werden kann. Ist sie das nich wird sich ein Platz auf der Treppe geteilt ;)

    Zur Zeitbeschränkung: Jeder Computer ist unterschiedlich schnell. Daher habe ich ein kleines Skript geschrieben welches bei mir ca. 0.2 Sekunden benötigt. Mein Algorithmus ist nicht besonderst komplex, liegt aber weit unter diesem Wert, daher sollte das locker ausreichen. Ihr könnt eure Methoden ja mal ausstoppen und Vorschläge für die Zeitbeschränkung abgeben. Ich vermute, dass man in 0.2sek ein 8x8 Feld schon fast per BF lösen kann.

    Spoiler anzeigen
    [autoit]

    ConsoleWrite(GetTime() & @CRLF)

    [/autoit] [autoit][/autoit] [autoit]

    Func GetTime()
    Local $n = 75, $t
    For $i = 0 To $n - 1 Step 1
    $t += _GetTime()
    Next
    Return Round($t, 0)
    EndFunc

    [/autoit] [autoit][/autoit] [autoit]

    Func _GetTime()
    Local $t = TimerInit(), $v = DllStructCreate('float a[5]'), $a[] = [99,88,77,66,55,44,33,22,11], $b[16][16]
    For $o = 0 To 9 Step 1
    For $i = 1 To 5 Step 1
    $v.a(($i)) += ($i / $a[Random(0, UBound($a) - 1, 1)])^2
    Next
    Next
    For $x = 0 To UBound($b, 1) - 1 Step 1
    For $y = 0 To UBound($b, 2) - 1 Step 1
    If $x = $y Then $b[$x][$y] += (($x^2 + $y^2)^0.5 / $a[Random(0, UBound($a) - 1, 1)])
    $b[$x][$y] += $v.a((Mod($x + $y, 5) + 1))
    If $b[$x][$y] < 0.5 Then $b[$x][$y] = ($b[$x][$y] + $b[$y][$x]) ^ 0.5
    Next
    Next
    Return TimerDiff($t)
    EndFunc

    [/autoit]

    Auch hier ist die Zeit nicht bei jedem Ausführen identisch, das ist nicht weiter tragisch, da sie nur als "richtwert" gilt. Es wird niemand disqualifiziert nur weil er etwas mehr Zeit braucht.

    Edit: (Für alle die noch nicht genau wissen was sie von den vielen "Zufällen" und der damit verbundenen "willkürlichen" Bewertung halten sollen)
    Meine Idee für den vergleich verschiedener Funktionen kann man sich ggf nur schwer vorstellen. Daher habe ich das ganze mal in Excel eingehämmert um zu demonstrieren wie das gemeint ist:
    Der Inhalt kann nicht angezeigt werden, da er nicht mehr verfügbar ist.
    Wir sehen 4 verschiedene Lösungsmethoden:
    1. Der Berühmte Zufall [Rnd]
    2. Die Modulomethode [Mod] (zählt einfach die Zahlen von 0 bis 5 der Reihe nach durch)
    3. Testet unmittelbar angrenzende Felder und wählt die am häufigsten vorkommende Farbe [M01] (es werden keine "Flächen" sondern wirklich nur die unmittelbar zu grauen Feldern benachbarten gezählt)
    4. Gleiche Methode wie [M01] nur mit einer Berechnungsebene mehr. [M02] (Berechnet also nach Schema M01 ZWEI Schritte statt nur einen)
    Zum Diagramm: Die dünnen Linien zeigen die tatsächlichen Messwerte, die dicken Linien zeigen eine geglättete Version.
    -> Man sieht: M01 und M02 überschneiden sich deutlich. In vielen Fällen ist also M01 "besser" als M02. Anhand der Kurve sehen wir aber, dass M02 im Prinzip einen Vorsprung von Durchschnittlich (ca.) 3 Besitzt. OBACHT: Die angewendete Methode benutzt bereits Mittelwerte aus 10er Paketen. Das heißt, dass die einzelnen Mittelwerte nicht sehr aussagekräftig sind, würde man über 100er Pakete Mitteln sähe das Bild eventuell etwas klarer, aber immernoch ähnlich aus.
    Dieses Schema zeigt die Methode nach der bewertet wird.

  • Wettbewerb (für Anfänger und Fortgeschrittene) ?

    Update des Beispielskripts siehe Startpost.
    Bitte mal im Manuellen Modus ein paar Spiele spielen um zu testen ob er jetzt ordentlich funktioniert. Wie Andy in Post 5 bereits gesagt hat, hat der alte Algorithmus öfters mal angrenzende Felder nicht erkannt... Das sollte jetzt besser funktionieren, mehr Augen sehen mehr, bei meinen 5 Testspielen lief jedenfalls alles tadellos.

    @MG:
    1. Siehe Andy (post11): Die _solveMarkeGrafik01 (so soll der Name später mal aussehen) Funktion darf aus einem beliebig komplexen Skript bestehen, es gibt keine Größenbeschränkung, allerdings muss das Skript aus einer Datei bestehen.
    2. Die Größe wird variiert. Vermutlich wird es Klein (8x8), Mittel (12x12), Groß (16x16) und Riesig (24x24). Vorallem für die kleinen und Mittleren Felder kommt hier nämlich die Methode des Vorausberechnens zum Tragen (also z.B. die nächsten 3 Züge (bei sehr klein geht auch BF) berechnen). Für Große Felder wäre die Laufzeit einer Vorausberechnung viel zu groß, daher ist hier Kreativität gefragt wie man auch so ein sehr gutes Ergebnis bekommt ;)
    3. Die Zeit ist beschränkt. Wie genau diese Beschränkung aussieht kann ich leider nicht sagen, da ich bisher selbst noch keine KI geschrieben habe und nicht weiß wie schnell oder langsam sich etwas lösen lässt. Es wird aber so aussehen, dass Brute Force nicht (vollständig) genutzt werden kann. Ein kleines 8x8 Feld kann man damit ggf bis zu 3-4 Stufen vorausberechnen, für ein 16x16 Feld wird die Zeitbeschränkung das aber verhindern. Wenn man den vorgegebenen Wert nur um ein paar Prozent (evtl. 20%) überschreitet wird das keine Auswirkungen auf die Bewertung haben, so genau lässt sich meistens sowieso nicht programmieren, dass man in jeder Situation eine Zeit genau einhalten kann. Besonderst schnelle Skripte bekommen KEINEN Bonus (sonst ist man mit der Random(0, 5, 1) Funktion auf Platz 1, frei nach dem Motto: Ich rechne es zwar falsch, dafür aber verdammt schnell).

  • Wettbewerb (für Anfänger und Fortgeschrittene) ?

    Hatte den Fehler auch gerade. Interessant 8o
    Und hab ihn auch im Code gefunden. Dazu muss aber ein mittelgroßer Teil neugeschrieben werden. Das Problem ist, dass ich keine Rekursion verwenden wollte damit der Rechenaufwand beim _Apply klein bleibt. Das wirft aber das Problem auf, dass in manchen (seltenen, aber immer wieder auftretenden) Situationen Farben nicht entdeckt werden, da sie zum Zeitpunkt an dem sie überprüft werden keine Grauen nachbarn haben.
    Habe aber keine Lust auf Rekursion, deshalb wird morgen eine iterative Methode gebaut. Muss den Code allgemein noch aufräumen, wir haben hier ja erstmal nur ein "konzept" ;)

    Edit: Für annähernd Zufallsverteilte Variablen gibts die Signifikanzniveauabschätzung. Soll heißen man kann den Mittelwert beliebig genau bestimmen wenn man beliebig viele Versuche hat.

  • Wettbewerb (für Anfänger und Fortgeschrittene) ?

    Ich habe mir schon gedacht, dass diese Frage kommt ;)
    Hier geht es um Wahrscheinlichkeiten. Um eine faire Bewertung zu haben müssten alle Teilnehmer die gleichen Farben bekommen. Für zufällige Farben stellt sich erst bei einem großen Stichprobenumfang ein Anständiges Ergebnis heraus.

    Ich habe also 2 Möglichkeiten:
    1. Viele Durchläufe (würde ich bevorzugen, da rennt der Rechner eben eine Weile)
    2. Viele Durchläufe + Gleiche Farben

    Ich bevorzuge Variante 1, da jeder Algorithmus (abgesehen von BruteForce) bei einigen Zufälligen Farben unterschiedlich abschneiden wird. Man hat also sowieso einen Zufall mit im Spiel. Und man sieht ja bereits bei einer Hand voll Versuche den Großen Unterschied zwischen AI1 und AI2, also denke ich, dass man bei einer Großen Anzahl Runden auch ziemlich genau sagen kann wie "gut" ein Algorithmus ist. Falls natürlich mehrere Kandidaten sehr dicht beieinander liegen (hierfür ist die StdA) werden diese nochmal gesondert betrachtet (mit mehr Durchläufen). Sollten sie dann immernoch gleichauf ein wäre es unfair den "besseren" zufällig zu bestimmen indem man beiden die gleichen 10.000 Muster vorgibt, denn villeicht wäre bei anderen 10.000 Mustern der andere vorne. In dem Fall werden sich mehrere Leute einen Platz teilen.

  • Wettbewerb (für Anfänger und Fortgeschrittene) ?

    Moin,
    Wie der Titel schon lautet möchte ich wissen wie viele Menschen, Roboter (oder was ihr alle seid) interesse an einem (kleinen) Wettbewerb haben. Eines vorweg: Es geht hier um den Spaß an der Angelegenheit, es gibt kein Preisgeld und auch kein 2t (oder 3t) klassiges Banner zum in die Signatur kleben.

    Thema:
    Trockener Matheunterricht mit Differentialgleichungen. Ein Skript welches ein "Spiel" möglichst effizient spielt. (sogesehen ein Bot, in unserem Fall ist dieser aber eher mit einem Sudokulöser vergleichbar, daher gibt es keine Probleme ;)).
    Das Spiel hat einen extrem einfachen Aufbau (sowohl optisch, als auch intern) und kann von jedem problemlos verstanden und gelöst werden. Es handelt sich um nebeneinander liegende Rechtecke unterschiedlicher Farbe (bei uns gibt es 7 Farben = 3 Grundfarben + 3 Mischfarben + Grau) die im Spielverlauf alle grau werden sollen. Das oberste linke Rechteck ist grau, der Rest bunt. Nun wählt man eine der 6 übrigen Farben (nummeriert von 0 bis 5) die das graue Rechteck berührt, um alle an graue Rechtecke anschließenden Farbflächen grau zu färben.

    Ich glaube je mehr ich hier erkläre, desto unverständlicher wird es. Daher gibts im Anhang einen Ordner der das Spiel, und ein paar Testdateien enthält.
    In der Gray.au3 (superkreativer Name) kann man in Zeile 6 auf Handbetrieb schalten, damit man das Spiel auch mal als Mensch spielen kann.
    Mit der GrayContest.au3 (obacht, AutoSolve wieder auf True setzen) kann man sich einen kleinen Eindruck verschaffen wie der Vergleich (in etwa) aussehen wird.

    Die beiden BeispielAIs (wenn man diese komplexen Dinger denn so nennen darf) zeigen was beim Wettbewerb von Teilnehmern erwartet wird ;) (ps: wer diese beiden nicht schlägt möge sich einschiffen lassen)

    Regelwerk:
    Ich habe mir selbst schon einiges überlegt, insgesamt gilt natürlich die Mentalität.
    - Es wird irgendein Zeitlimit geben um den nächsten Zug zu berechnen.
    - COM, ASM, Dlls -> verboten (also keine VBS Objekte zum Geschwindigkeitcheaten)
    - Das Hauptskript darf nicht verändert werden. Für den Wettbewerb werden alle Dateien außer die Einsendungen durch die Originale ersetzt
    - usw.

    Einen Zeitraum habe ich nicht vorgesehen, schlage aber vor irgendeine Novemberwoche zu nehmen. (selbstverständlich ist es jedem Selbst überlassen wann er etwas tut. Es gibt also keinen "Beginn", sondern nur einen Einsendeschluss)

    Edit: 02.11.2014 - Version 0.2 (die alte war 0.1)
    Update der Beispieldatei: Neuer Algorithmus (Knotenbasiert statt Arraybasiert)
    - In vielen Fällen deutlich schneller als der alte
    - Hoffentlich dieses mal auch vollständig korrekt (der alte hat öfters mal Farben nicht "gesehen" und daher falsch gearbeitet)

    Edit: 06.11.2014 - Version 0.3
    - Array kann nicht mehr ByRef bearbeitet werden :P
    - Zeitmessung eingebaut
    - Contestskript etwas angepasst
    - Alle Globalen Variablen beginnen nun mit _gr_ oder _wb_, damit es keine Kollisionen gibt.
    - OBACHT: Da alle Skripte includet werden ist es ratsam die Funktionen/Variablen irgendwie benennen, sodass Kollisionen verhindert werden. (z.B. wenn ich Käsekuchen73 heiße nenne beginnen alle funktionen/vars mit _k73_).
    - Zur Namensgebung der Lösungsfunktion: Diese darf man frei benennen (muss mit korrektem Namen registriert werden). Denkt euch was Kreatives aus ;) (mein "Kampfskript" heißt dann Marsterplan64 oder so ähnlich ;) )

    lg
    Mars

  • [Stylish] Oldschool-Shoutbox

    Optik für die Onlineanzeige des Teams (Admins/Mods/PUs):

    CSS
    #portalBox9 .icon-desktop:before {      vertical-align: middle;      content: "";      color: #00bb00;      text-shadow: 0px 0px 3px;    }    #portalBox9 .icon-check-empty:before {      vertical-align: middle;      color: #909090;      content: "";    }    #portalBox9 > .container ul ol li:nth-child(even) {      background: #e0e0e0    }    #portalBox9 > .container ul ol li {      font-size: 80% !important;    }

    [Blockierte Grafik: http://i.imgur.com/XIJ6bwy.png]

  • [Stylish] Oldschool-Shoutbox

    Optik für die Titelleiste:
    (Grafiken sind aus den Wettbewerbthreads für Logo und BG-Bild)

    CSS
    img[src='http://autoit.de/wcf/images/lightedged/logo.png'] {      height: 0 !important;      width: 0 !important;      padding-left: 468px !important;      padding-top: 60px !important;      background: url(http://autoit.de/index.php/Attachment/23457-Logo-png/) no-repeat !important;    }    #pageHeader > div {      background: url('http://i.imgur.com/RuRIN.png') !important;    }

  • Forum-Umstellung Problemsammlung

    - [PU] Beiträge deaktivieren (wollte jetzt nicht wild herumklicken, eventuell hab ichs auch übersehen)
    - [Linke Portalspalte - Team] Ich persönlich finde die Bilder könnten verschwinden, wie das andere sehen weiß ich nicht. - Gefixt. Bilder entfernt
    - [Shoutbox] Auch hier wird viel (vorallem horizontal) Platz durch die Bildchen verbraucht - (von Mars) Ist nicht unsere SB
    - [Forum] Den Schriftzuf "Angepinnt" wieder in irgendein Bildchen umwandeln