Awalé Programmeerwedstrijd

Programmeer Challenge Jeu Awalé

Dit jaar organiseert het bedrijf waar ik werk voor het eerst een programmeer Challenge. Bij deze programmeerwedstrijd is het de bedoeling dat engines van verschillende deelnemers het spel Awalé tegen elkaar spelen.

Het van oorsprong Afrikaanse spel Awalé zou wel eens het oudste bordspel ter wereld kunnen zijn. Zijn geschiedenis gaat duizenden jaren terug. Door het almaar groeiende aantal toeristen dat door Afrika trekt, wordt Awalé ook op andere continenten steeds bekender en populairder.

Spelregels

In het kort. Awalé is een bordspel dat begint met een bord met 2x6 velden gevuld met elk 4 zaden. Een beurt bestaat uit 2 delen, het zaaien en het eten. Zaaien doe je door alle zaden uit één veld te pakken en deze per stuk tegen de klok in te verdelen in de andere velden. Als in het veld waar je het laatste zaadje zaait zich aan de zijde van de tegenstander bevindt, dan moet je zaden uit dit veld eten als er twee of drie zaden op liggen. Zolang aan deze condities wordt voldaan, gaat men één voor één alle velden af met de wijzers van de klok mee om ook hier zaden te eten. Degene die als eerste meer dan 24 zaden heeft gegeten heeft gewonnen.

Aard en doel van Awale

Het spel wordt gespeeld tussen twee tegenstanders die om beurten ‘zaden zaaien’ op het speelbord en (indien van toepassing) ‘eten’ van het speelbord.
Het is de bedoeling van elke speler om meer zaden te eten dan de tegenstander. Het spel gaat net zo lang door tot dat een van beide spelers niet meer kan zaaien. De speler die gedurende het gehele spel de meeste zaden gegeten heeft is winnaar.
Als beide spelers evenveel zaden hebben gegeten is het spel remise.

Beginopstelling

Het speelbord bestaat uit twee zijden van elk zes velden. Elke speler heeft een zijde ter beschikking.
De speelstukken bestaan uit 48 zaden met identieke waarde en eigenschappen.
Een veld is een locatie op het speelbord waarin zich 0 tot en met 48 zaden kunnen bevinden (het aantal zaden binnen een veld moet altijd een geheel getal zijn). Een veld grenst links en rechts aan één ander veld, met uitzondering van het eerste en laatste veld. Het meest linkse veld grenst aan de linkerkant met het veld van de tegenstander hier tegenover. Het meest rechtse veld grenst aan de rechterkant met het veld van de tegenstander hier tegenover.
Bij het begin van het spel is ieder veld gevuld met vier zaden.

Zaaien

De aan zet zijnde speler kiest een van zijn/haar gevulde velden en neemt alle zaden uit dit veld in zijn/haar hand. Daarna gaat hij/zij tegen de wijzers van de klok in langs alle velden en zaait in ieder veld één zaadje totdat alle in de hand genomen zaden gezaaid zijn. Mocht hierbij het startveld weer aangedaan worden, wordt hier niet gezaaid en wordt met zaaien vervolgd in het direct hierop volgende veld. Het is op deze manier mogelijk dat in een beurt meerdere malen één zaadje in één en hetzelfde veld wordt gezaaid.
Als alle velden van de tegenstander leeg zijn en de aan zet zijnde speler heeft ten minste één mogelijkheid om een zet te doen waarbij ten minste één veld van de tegenstander wordt gevuld met ten minste één zaadje, dan is de speler verplicht deze zet te doen.

Eten

De fase waarin zaden gegeten mogen worden volgt iedere zet nadat de speler het zaaien heeft afgerond.
Bij het bepalen of er zaden en (indien van toepassing) welke zaden gegeten worden gaat men als volgt te werk: men begint bij het veld, waar men in de zaaifase is geëindigd met zaaien van het laatste zaadje. Indien dit veld zich aan de zijde van de tegenstander bevindt, dan wordt dit veld leeg gegeten als er twee of drie zaden op liggen. Zolang aan deze condities wordt voldaan, gaat men één voor één alle velden af met de wijzers van de klok mee om ook hier zaden te eten.
Gegeten zaden worden uit het spel genomen. Er wordt bijgehouden hoeveel zaden door iedere speler gegeten worden.

Einde van het spel

Het spel is afgelopen wanneer een van beide spelers niet meer kan zaaien. Als de andere speler nog zaden op zijn zijde heeft, worden deze aan zijn totaal van gegeten zaden toegevoegd.
Wanneer een identieke positie zich voor de tweede keer voordoet wordt het spel beëindigd. De zaden die zich dan nog op het bord bevinden worden buiten beschouwing gelaten.

Het schrijven van een engine

De engine moet geschreven worden in C# 1.1, 2.0, Java JDK 5 of 6. Dit is een console applicatie die opgestart wordt met als enige parameter de url naar de webservice van de gameserver.
Van de gameserver krijgt één van de spelers het signaal dat de eerste zet gedaan mag worden. Na het doen van de eerste zet krijgt de andere partij te horen welke zet dit was en mag daarop antwoorden. De precieze specificaties van de webinterface zijn nog niet bekend. Zodra de exacte specs (waaronder de wsdl) bekend zijn worden ze hier uiteraard gepost. Maar ook zonder deze specs zijn er een genoeg interessante zaken te programmeren en te bediscussieren.

Er zijn verschillende methoden die je kunt gebruiken voor de AI van je Awalé engine. Voor programmeurs die nog nooit iets met AI gedaan hebben, volgen hier een paar technieken en links in de goede richting.

Minimax

Minimax is een manier om de beste volgende zet te bepalen. Meer hierover op http://en.wikipedia.org/wiki/Minimax_theorem
Om de de zoekboom van minimax te beperken is kunnen alpha-beta pruning en een transposition table gebruikt worden.

Alpha beta pruning

Alpha beta pruning zorgt ervoor dat kansloze beslissingen niet verder doorgerekend worden. Meer hierover op http://en.wikipedia.org/wiki/Alpha-beta_pruning

Transposition table

Het is mogelijk om met verschillende moves op dezelfde stelling uit te komen. Om dezelfde stelling (op een ander punt in de zoekboom) niet steeds opnieuw te evalueren kun je een transposition table gebruiken. Meer hierover http://en.wikipedia.org/wiki/Transposition_table

Neurale netwerken

Neurale netwerken zijn ontworpen naar analogie van het menselijk brein en kan getraind worden op vanalles en nog wat. Meer hierover http://nl.wikipedia.org/wiki/Neuraal_netwerk

Genetisch programmeren

Genetisch programmeren is gebaseerd op het idee van evolutie. Je begint met willekeurige engines die tegen elkaar spelen. De winnaars gaan door naar de volgende generatie, bovendien creëer je nieuwe engines door eigenschappen van winnende engines met elkaar te combineren. Door steeds de winnaars door te laten gaan zullen de engines steeds beter worden. Meer hierover http://nl.wikipedia.org/wiki/Genetisch_algoritme

Pondering

Geen AI techniek, maar wel een mogelijkheid om jouw engine voordeel te geven tov de opponent. Met pondering wordt bedoeld dat je ook 'denkt' in de tijd van de tegenstanders. Elke engine wordt uitgevoerd op een eigen fysieke machine, dus je hebt de hele processor voor jezelf. Het zou zonde zijn deze niet te gebruiken

Meedoen

Je kunt meedoen door je hier http://www.tjip-challenge.com/ik_doe_mee.html in te schrijven.
De introductiebijeenkomst is al zaterdag 23 juni (aanstaande zaterdag), dus wees er snel bij.
Meer informatie vind je op deze site: http://www.tjip-challenge.com

Waarom dit topic

Het doel van dit topic is om de technische kanten van de wedstrijd te bespreken. De belangrijkste component is het bespreken van mogelijke strategieën, zodat dit een leerzaam topic over AI mbt bordspelen wordt. Daarnaast is het al een discussie op zich hoe je het beste een Awalé bord kunt representeren en hoe je daar efficiënt zetten op doorvoert. Hoe efficiënter, hoe meer zetten je vooruit kunt denken en daarmee haal je dus winst tov de tegenpartij .

update 16-07-2007

De nieuwe spelregels staan online. Hierin zijn een aantal puntjes opgenomen die in dit forum naar boven zijn gekomen.
- De link naar de wsdl (2.2.1)(wsdl)
- Je mag je tegenstander alleen leeg eten als dat de enige mogelijke zet is (4.3.3)
- Code blijft eigendom van de deelnemer (5.3)

De finale is verzet naar zaterdag 29 september 2007.
ps. Er is toestemming van de crew.

Sjaaky wijzigde dit bericht 16-07-2007 15:09 (6%)

http://www.awari.cs.vu.nl/
http://s.helan.free.fr/awele/

quote:

ambi schreef op donderdag 21 juni 2007 @ 09:41:
http://www.awari.cs.vu.nl/
http://s.helan.free.fr/awele/

Ga je ook nog inhoudelijk wat zeggen of laat je het bij deze twee links? Dit is dus niet de bedoeling.

Altijd een beetje jammer als de te gebruiken programmeertalen beperkt worden in zo'n wedstrijd. Er zijn nog zoveel andere talen waarin je dit zou kunnen schrijven!

Het is natuurlijk stiekem gewoon ook een wervingsactie voor c#-ers en java-ers.

Overigens had je er ook wel bij mogen vermelden dat als je je IT cv op monsterboard zet je het spel opgestuurd krijgt met de hele wedstrijduitleg (zo kwam ik achter deze wedstrijd)

Ik zie nergens iets staan over eigendom van de ingezonden code. Bij dit soort acties staat vaak in de kleine lettertjes dat de ingezonden deelnames eigendom van de organisator worden. Wellicht verstandig om dat iig even expliciet te maken.

quote:

Manuzhai schreef op donderdag 21 juni 2007 @ 10:24:
Altijd een beetje jammer als de te gebruiken programmeertalen beperkt worden in zo'n wedstrijd. Er zijn nog zoveel andere talen waarin je dit zou kunnen schrijven!

Meestal wordt er maar 1 taal geaccepteerd. Daarnaast gaat het bij een dergelijke wedstrijd meer over de algoritmen dan over de daadwerkelijke taal. Wanneer je je probleem in de ene taal op zou kunnen lossen dan moet je dat in de andere taal ook wel lukken. Met .net en java heb je alvast een enorme dekking mbt beschikbare kennis bij deelnemenrs (en nee, php is geen serieuze optie bij een dergelijk turnbased communiserende console applicatie)

@ambi:
Deze online spellen zijn handig om een gevoel te krijgen met het spel. Awalé/Awari/... bestaat in verschillende varianten met subtiele verschillen in regels. Ik weet niet of deze online varianten exact dezelfde regels implementeren.
Het spel Awalé is 'uitgeplugd'. Dat wil zeggen dat voor elke bordpositie de optimale volgende zet bekend is. Wij hebben beperkingen opgelegd dat de uiteindelijk gecompileerde code niet meer dan 1MB(1048576 bytes) mag zijn om te zorgen dat er geen complete lookuptables van het spel worden gebruikt. Dat neemt volgens de site van de vu nogal wat data in. Om te voorkomen dat mensen externe databases gaan benaderen, heeft de pc waarop een awale engine draait geen internet verbinding.

@Manuzhai:
Samen met de punten die Janoz aandraagt, is de reden om de programmeertalen te beperken tot c# en java dat wij daar ervaring mee hebben. Bovendien moeten we voor elke taal een omgeving inrichten waarin de engine gecompileerd en uitgevoerd moet worden.

@sopsop:
Eigendom van de code blijft bij de deelnemers.

Sjaaky wijzigde dit bericht 21-06-2007 15:10 (12%)

De deelnemers mogen op 1 MB aan gecompileerde source uitkomen.

Betekent dit dat deze 1 MB volledig uit class files moet bestaan. Of mag het programma ook gebruik maken van andere bestanden die binnen deze 1 MB vallen?

quote:

Janoz schreef op donderdag 21 juni 2007 @ 11:14:
Meestal wordt er maar 1 taal geaccepteerd. Daarnaast gaat het bij een dergelijke wedstrijd meer over de algoritmen dan over de daadwerkelijke taal. Wanneer je je probleem in de ene taal op zou kunnen lossen dan moet je dat in de andere taal ook wel lukken. Met .net en java heb je alvast een enorme dekking mbt beschikbare kennis bij deelnemenrs (en nee, php is geen serieuze optie bij een dergelijk turnbased communiserende console applicatie)

Beetje jammer dat je mij ongeveer al bij voorbaat classificeert als een PHP'er. Ik zou eerder denken aan Python, Ruby, misschien Haskell, OCaml? En *juist* als het alleen maar over het algoritme gaat zou ik liever een taal gebruiken waarbij ik niet allemaal line noise zoals statische typering hoef op te nemen (misschien een beetje een flamebait, maar goed).

Ik wilde toch nog even de regel over het slaan van alle zaden van de tegenstander ter discussie brengen.

Volgens mij zijn er 2 varianten: voor de live toernooien wordt gespeeld dat de zet is toegestaan maar geen zaden slaat (dus alle zaden die normaal gesproken geslagen zouden zijn blijven liggen als het de tegenstander anders na het slaan geen zaden meer heeft).

Voor computerwedstrijden wordt doorgaans de regel aangehouden dat de zet alleen is toegestaan als er geen andere optie is (dus vergelijkaar met de regel dat je de tegenstander alleen mag verhongeren als je geen andere keus hebt)

In het laatste geval is de regel heel simpel: de tegenstander moet nog zaden hebben na jouw zet. Heb je daardoor geen legale zetten dan mag je al je zetten doen en krijg je daarna alle zaden op het bord. De eerste regel is mss wat lastiger te implementeren omdat zetten niet zo makkelijk zijn terug te nemen.

De regel die op de introductiebijeenkomst was voorgesteld is natuurlijk nog simpeler te coden, maar verpest het spel wel een beetje. Ik heb vanochtend nog een potje gespeeld waar het na een zet of 20 (net begonnen) 5-4 voor mn tegenstander stond, waarna ik al haar stenen kon slaan en dan met 43-5 zou winnen. (speelden we uiteraard niet op erg hoog niveau ) Dat is echter tegenstrijdig met de regel dat je iemand niet bewust mag verhongeren en die regel is er ook met een reden (anders is het puur een kwestie van zorgen dat je meer vrije zetten krijgt dan je tegenstander er kan doen en em dan verhongeren en dus winnen). Met de regel op deze manier is verhongeren dus opeens wel weer mogelijk, wat een erg ingrijpende wijziging op het spel is.

Als het een bewuste keuze is om het spel een beetje aan te passen dan lijkt me dit niet de meest geschikte manier, als het geen bewuste keuze is lijkt het me beter een bestaande regel te gebruiken. Aangezien het de bedoeling is dat het winnende programma getest wordt tegen een afrikaanse topspeler lijkt me de laatste variant beter om te voorkomen dat de winnaar met laptop en al wordt opgegeten om zn rare ideeen over dit spel

"Het is niet toegestaan om bestanden te lezen of te schrijven."
De reden hiervoor is om te zorgen dat je geen bestand met resultaten uitrekent in partij 1 en deze weer gaat gebruiken in volgende partijen. Embedded resources in .net bevinden zich wat dat betreft een beetje op de grens. Deze kun je wel lezen, maar niet schrijven. Daarom hebben we besloten dat embedded resources ook niet toegestaan zijn.
Als je een vaste datastructuur met gegevens in je programma wilt gebruiken kun je deze in code uitschrijven en als een struct of class statisch initialiseren. Dat is voor de jury ook een stuk prettiger .

http://www.myriad-online....s/awale/english/rules.htm

Ik heb toevallig net het spel gekocht en lang gezocht naar de meest algemene (en speelbare) regels.
Bovenstaande beschrijving gebruikt deze regels, maar beschrijft niet alle uitzonderingen. Dit linkje doet dat wel. Let vooral op de al vermelde regel van het uithongeren van je tegenstander en de loop of 'Krou'.

quote:

vdeboer schreef op zondag 24 juni 2007 @ 14:05:
Dat is echter tegenstrijdig met de regel dat je iemand niet bewust mag verhongeren en die regel is er ook met een reden (anders is het puur een kwestie van zorgen dat je meer vrije zetten krijgt dan je tegenstander er kan doen en em dan verhongeren en dus winnen). Met de regel op deze manier is verhongeren dus opeens wel weer mogelijk, wat een erg ingrijpende wijziging op het spel is.

Dat lijkt me wel erg simpel gesteld. Als je meer vrije zetten hebt, betekent het alleen dat je je tegenstander kan dwingen om een zaad op jouw helft te spelen, voordat jij het omgekeerde doet. Maar meestal heb je niet genoeg vrije zetten voordat je tegenstander heel zijn helft heeft leeggespeeld.

En wat betreft de wedstrijd in Senegal: Ik denk dat de winnaar zijn/haar programma nog vast eventueel kan aanpassen voor vertrek.


(leuke google-ads trouwens )

Het is niet makkelijk, maar zo eindigen alle potjes wel. Het aantal stenen dat je pakt door verhongeren is dan vaak veel hoger dan wat je hebt kunnen pakken voor het is afgelopen waardoor het veel belangrijker is dat je de uithonger strijd wint dan dat je wat zaden veroverd. Als je mag verhongeren moet je evaluatie-funcie een hele hoge waarde toekennen aan het aantal zetten dat je kan doen zonder de tegenstander te feeden, terwijl zonder verhongeren het toekennen van een hoge waarde daaraan juist averechts lijkt te werken. Het is dus niet puur een kwestie van de regels even aanpassen...

Zonder de regel dat je alles mag slaan kan je door uithongeren hooguit 15 stenen krijgen, en dat is heel erg onwaarschijnlijk (5,4,3,2,1,0 stenen in de vakjes, maar is lastig een pad naar die situatie toe te bedenken) Denk dat als je er een steentje of 5 a 6 mee krijgt dat het al veel is. Dan moet je dus al minstens 20-23 staan voor het kan. Das wat anders dan dat je bij 4-5 al kan winnen door 39 zaden te slaan in 1 beurt, wat op heel veel manieren kan.

vdeboer wijzigde dit bericht 25-06-2007 14:28 (27%)

Afgelopen zaterdag was er een kickoff. Zeer gezellig, maar bovenal ook zeer nuttig. Er is beloofd om de wsdl te publiceren: linkje.

Verder nog een stukje code in C# om duidelijk te maken wat de gameserver eigenlijk verwacht:
C#:

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134 135 136 137 138 139

using System; namespace Tjip.Game.Awale.Server {     /// <summary>     /// Represents the status of the Awale server.     /// </summary>     public enum GameServerStatus     {         /// <summary>         /// The server has no tournament loaded.         /// </summary>         Initializing,         /// <summary>         /// A tournament has been loaded but the current round has not been started.         /// </summary>         Loaded,         /// <summary>         /// A tournament has been started and player can start to play.         /// </summary>         Playing,         /// <summary>         /// The current round or the tournament has finished.         /// </summary>         Finished     }     /// <summary>     /// Represents the status of the players match.     /// </summary>     public enum MatchStatus     {         /// <summary>         /// There is no match available for the player.         /// </summary>         None,         /// <summary>         /// The match has not been started.         /// </summary>         Waiting,         /// <summary>         /// The match is currently playing.         /// </summary>         Playing,         /// <summary>         /// The player has won the match.         /// </summary>         Won,         /// <summary>         /// The players match was ended in a draw.         /// </summary>         Draw,         /// <summary>         /// The player has lost the match.         /// </summary>         Lost     }     /// <summary>     /// Represents the information on who should start the match.     /// </summary>     public enum MatchStart     {         /// <summary>         /// The player should start the match.         /// </summary>         Player,         /// <summary>         /// The players opponent starts the match.         /// </summary>         Opponent,         /// <summary>         /// The match has already finished.         /// </summary>         Finished     }     /// <summary>     /// Interface for the users awale gameserver.     /// <remarks>     /// The server will start the match with this board layout.     /// ==opponent==     /// -------------------------------------     /// | (5) | (4) | (3) | (2) | (1) | (0) | == field     /// |  4  |  4  |  4  |  4  |  4     4  | == grains     /// |------------------------------------     /// |  4  |  4  |  4  |  4  |  4  |  4  | == grains     /// | (0) | (1) | (2) | (3) | (4) | (5) | == field     /// -------------------------------------     /// ==player==     /// </remarks>      /// </summary>     public interface IGameServer     {         /// <summary>         /// Method for checking the status of the server.         /// </summary>         /// <returns>Returns an enum representing the current status of the game server.</returns>         GameServerStatus GetServerStatus();         /// <summary>         /// Method for retreiving the players unique tournament identifier.         /// <remarks>This method is only valid when a tournament has been loaden on the gameserver.</remarks>          /// </summary>         /// <param name="login">The users unique login name.</param>         /// <returns>The players uinique id in the current loaded tournament.</returns>         string Logon(string login);         /// <summary>         /// Method for checking the status of the current match of the player.         /// </summary>         /// <param name="playerId">The players unique identifier.</param>         /// <returns>An enum representing the match status.</returns>         MatchStatus GetMatchStatus(string playerId);         /// <summary>         /// Method for starting the match.         /// </summary>         /// <param name="playerId">The players unique identifier.</param>         /// <returns>An enum representing the player who should start.</returns>         MatchStart StartMatch(string playerId);         /// <summary>         /// Method for executing a move for the player.         /// </summary>         /// <param name="playerId">The players unique identifier.</param>         /// <param name="field">The players field to move.</param>         /// <returns>An enum representing the match status after the move.</returns>         MatchStatus Move(string playerId, int field);         /// <summary>         /// The player forfeits the match.         /// </summary>         /// <param name="playerId">The players unique identifier.</param>         void Resign(string playerId);         /// <summary>         /// Method for retreiving the opponents last move.         /// </summary>         /// <param name="playerId">The players unique identifier.</param>         /// <returns>         ///  0..5 : for the opponenets move.         /// -1    : the opponent has not moved yet.         /// -2    : the game has finished.         /// </returns>         int GetMove(string playerId);     } }

Hopelijk verduidelijkt dit de wsdl-interface aanzienlijk. Merk op dat er (waarschijnlijk) nog twee webmethods gaan komen: GetTime() (of als outparam bij Move) en Move(string playerId, int field, string log). Ik heb contact overgehad met de persoon die de gameserver maakt. Defintieve bevestiging hierover zal ik ook hier melden.

Omtrent het al dan niet laten verhongeren: Sjaaky en ik hebben daar mogen met een derde collega nog even kort overleg over, voordat we met een definitieve beslissing komen.

Kun je trouwens nog inzending insturen? Of had je je dan vorige week moeten inschrijven?

Op de introductiebijeenkomst zeiden de organisatoren dat mensen zich nog steeds konden inschrijven voor de wedstrijd. Ze moedigden het zelfs aan.
Nog niemand heeft trouwens een inzending gestuurd voor zo ver ik weet. Eerst moet de gameserver online komen, dan kunnen mensen hun programma daar testen.
En volgens mij kun je wachten met je inzending insturen tot de finaledag ergens in september (of was het oktober?).

Ben je verplicht als je je inschrijft om ook echt wat in te leveren?

En moet je bij de finaledag/voorrondedagen aanwezig zijn?

Even een vraagje: tijdens de introductiebijeenkomst heb ik gevraagd of het altijd verplicht is om te oogsten wanneer dat mogelijk is. Het antwoord was dat dat niet verplicht is. Uit de wsdl maak ik echter op dat het (nog) niet mogelijk is om het aantal te oogsten velden op te geven:
XML:

1 2 3 4 5 6 7 8

- <s:element name="Move"> - <s:complexType> - <s:sequence>   <s:element minOccurs="0" maxOccurs="1" name="playerId" type="s:string" />    <s:element minOccurs="1" maxOccurs="1" name="field" type="s:int" />    </s:sequence>   </s:complexType>   </s:element>

Hmm NaliXL, dan heb ik je vraag toen niet goed begrepen denk ik. Ik dacht dat je bedoelde dat je, als er een zet was die eten toestond, díe moest uitvoeren. Maar nu lees ik uit je vraag dat je zelf mag bepalen hoeveel je eet, als je een 'eet'-zet doet. Dat is niet het geval. Als je een zet uitvoert is die maar op één manier af te handelen. Hopelijk is het nu duidelijk. Zo niet, dan hoor ik het wel.

@mstassen: Zaterdag 6 oktober 2007.

@phsmit: Dat zien we wel graag, maar het is niet verplicht. Risico is natuurlijk wel dat je als je programma niet goed werkt, het een typisch geval is van: jammerdebammer. Wij gaan je prog. niet fixen op de dag zelf.

quote:

Corniel schreef op woensdag 27 juni 2007 @ 10:37:
@mstassen: Zaterdag 6 oktober 2007.

Dat is wel jammer.
Zaterdag 6 oktober is namelijk ook de dag van de universitaire voorrondes van het bapc, het studentenprogrammeerkampioenschap van de benelux, daar doe ik ook aan mee...
Ik weet niet hoveel studenten er onder de deelnemers zijn, de groep leek me diverser dan ik aanvankelijk dacht, maar waarschijnlijk toch wel wat studenten die graag programmeren. Die moeten dan kiezen.

Maar dan doe ik misschien net als phsmit ook vanaf afstand mee, want bij het universiteitskampioenschap moet ik echt aanwezig zijn. Hopelijk werkt mijn programma dan in 1 keer.

Is het zeker dat de finale op 6 oktober plaatsvindt?
Op http://www.tjip-challenge.com/de_wedstrijd.html staat namelijk dat de finale in september is.

We overwegen momenteel om de finale een weekend eerder te doen. Dat zou dan 29 september worden. Maar hierover horen jullie meer als het definitief is.

Ok, een week vroeger zou heel mooi zijn.