Abstract
Automatically evaluating source program files is a crucial part of programming contests. The evaluation aims at discriminating programs according to their correctness and efficiency. Given the performance of today's computers, in order to be able to distinguish the complexity of solutions, it is often necessary to use very large data sets. This is awkward, because it is against the nature of the stated problem and puts an unintended burden on the input operations. Besides, by advertizing a limit for the size of the input, the problem description gives away information with which the contestants may guess the algorithmic complexity that their solutions must attain. It would be more realistic to omit that information and let the contestants discover the limits by analyzing the problem, using a scientific approach. The complexity of the solution can then be estimated automatically by measuring the execution time of the function that solves the problem in incremental test cases, and plotting it against the size of the input. By calling the function multiple times and taking the overall time, we may use only data files the size of which is related to the nature of the problem being solved. © 2009 Institute of Mathematics and Informatics, Vilnius.

Abstract
Those who enjoy programming enjoy programming competitions, either as contestants or as coaches. Often coaches are teachers, who, aiming at better results in the future, would like to have more and more students participating, from earlier stages. Learning all the basic algorithms takes some time, of course; on the other hand, competition environments can be introduced right from the beginning as a pedagogical tool. If handled correctly, this can be very effective in helping to reach the goals of the course and, as a side-effect, in bringing larger crowds of students into the programming competition arena. © 2008 Institute of Mathematics and Informatics, Vilnius.

Abstract
Motivation plays a key role in the learning process. This paper describes an experience in the context of undergraduate teaching of Artificial Intelligence at the Computer Science Department of the Faculty of Sciences in the University of Porto. A sophisticated competition framework, which involved Prolog programmed contenders and game servers, including an appealing GUI, was developed to motivate students on the deepening of the topics covered in class. We report on the impact that such a competitive setup caused on students' commitment, which surpassed our most optimistic expectations. © 2009 Institute of Mathematics and Informatics, Vilnius.

Abstract
Programming contests should be capable of being appealing to both the contestants and the general public. We feel that the use of graphical user interfaces and computer graphics could help achieve this goal, providing new ways of viewing the task. We describe experiments we made with games (Tic-Tac-Toe, Snake and Ataxx, an Othello-like game), which were made available to students with graphical components, and discuss the results. We also present a simple graphic library where simple drawings can be made and show how it can be used in a programming contest environment. We then conclude by revisiting some past IOI problems, suggesting ways to enhance them with graphical components.

Abstract
This paper describes a fully complete autonomous hybrid robot system, named YAM (Yet Another Mouse), that is able to navigate through an unknown maze environment. YAM effectively tackles the problem of how to represent the environment using its sensor data to produce probability maps of the walls and beacons. Besides that, it is capable of computing long-term path plans using an adapted breadth-first search algorithm. It also shows how it is possible to model the actual motors behavior as a reactive task, using artificially created virtual short-term goals. We give real contest results, showing how YAM behaved on the "CiberRato" robotics competition.

Abstract
Many natural and artificial structures can be represented as complex networks. Computing the frequency of all subgraphs of a certain size can give a very comprehensive structural characterization of these networks. This is known as the subgraph census problem, and it is also important as an intermediate step in the computation of other features of the network, such as network motifs. The subgraph census problem is computationally hard and most associated algorithms for it are sequential. Here we present several increasingly efficient parallel strategies for, culminating in a scalable and adaptive parallel algorithm. We applied our strategies to a representative set of biological networks and achieved almost linear speedups up to 128 processors, paving the way for making it possible to compute the census for bigger networks and larger subgraph sizes.