IOI '12 P1 - Pebbling Odometer - DMOJ: Modern Online Judge

IOI '12 P1 - Pebbling Odometer

View as PDF

Submit solution

All submissions

Best submissions

Points: 30 (partial)

Time limit: 1.0s

Memory limit: 16M

Problem types

Allowed languages

Text

Leonardo invented the original odometer: a cart which could measure distances by dropping pebbles as the cart's wheels turned. Counting the pebbles gave the number of turns of the wheel, which allowed the user to compute the distance travelled by the odometer. As computer scientists, we have added software control to the odometer, extending its functionalities. Your task is to program the odometer under the rules specified below.

Operation Grid

The odometer moves on an imaginary square grid of $256 \times 256$ ~256 \times 256~ unit cells. Each cell can contain at most $15$ ~15~ pebbles and is identified by a pair of coordinates (row, column), where each coordinate is in the range $0, \dots, 255$ ~0, \dots, 255~. Given a cell $(i, j)$ ~(i, j)~, the cells adjacent to it are (if they exist) $(i-1, j)$ ~(i-1, j)~, $(i+1, j)$ ~(i+1, j)~, $(i, j-1)$ ~(i, j-1)~ and $(i, j+1)$ ~(i, j+1)~. Any cell laying on the first or last row, or on the first or last column, is called a border. The odometer always starts at cell $(0, 0)$ ~(0, 0)~ (the north-west corner), facing north.

Basic Commands

The odometer can be programmed using the following commands.

left - turn $90$ ~90~ degrees to the left (counter clockwise) and remain in the current cell (e.g. if it was facing south before, then it will face east after the command).
right - turn $90$ ~90~ degrees to the right (clockwise) and remain in the current cell (e.g. if it was facing west before, then it will face north after the command).
move - move one unit forwards (in the direction the odometer is facing) into an adjacent cell. If no such cell exists (i.e. the border in that direction has already been reached), then this command has no effect.
get - remove one pebble from the current cell. If the current cell has no pebbles, then the command has no effect.
put - add one pebble to the current cell. If the current cell already contains $15$ ~15~ pebbles, then the command has no effect. The odometer never runs out of pebbles.
halt - terminate the execution.

The odometer executes the commands in the order they are given in the program. The program must contain at most one command per line. Empty lines are ignored. The symbol # indicates a comment; any text that follows, up to the end of the line, is ignored. If the odometer reaches the end of the program, execution is terminated.

Example 1

Consider the following program for the odometer. It takes the odometer to the cell $(0, 2)$ ~(0, 2)~, facing east. (Note that the first move is ignored, because the odometer is on the north-west corner facing north.)

move # no effect
right
# now the odometer is facing east
move
move

Labels, Borders, and Pebbles

To alter the flow of the program depending on the current status, you can use labels, which are case-sensitive strings of at most 128 symbols chosen from $a, \dots, z$ ~a, \dots, z~, $A,\dots, Z$ ~A,\dots, Z~, $0,\dots, 9$ ~0,\dots, 9~, and $\_$ ~\_~. The new commands concerning labels are listed below. In the descriptions below, $L$ ~L~ denotes any valid label.

L: - (i.e. $L$ ~L~ followed by a colon :) - declares the location within a program of a label $L$ ~L~. All declared labels must be unique. Declaring a label has no effect on the odometer.
jump L - continue the execution by unconditionally jumping to the line with label $L$ ~L~.
border L - continue the execution by jumping to the line with label $L$ ~L~ if the odometer is on a border facing the edge of the grid (i.e. a move instruction would have no effect); otherwise, the execution continues normally and this command has no effect.
pebble L - continue the execution by jumping to the line with label $L$ ~L~ if the current cell contains at least one pebble; otherwise, the execution continues normally and this command has no effect.

Example 2

The following program locates the first (westmost) pebble in row $0$ ~0~ and stops there; if there are no pebbles in row $0$ ~0~, it stops on the border at the end of the row. It uses two labels leonardo and davinci.

right
leonardo:
pebble davinci # pebble found
border davinci # end of the row
move
jump leonardo
davinci:
halt

The odometer starts by turning to its right. The loop begins with the label declaration leonardo: and ends with the jump leonardo command. In the loop, the odometer checks for the presence of a pebble or the border at the end of the row; if not so, the odometer makes a move from the current cell $(0, j)$ ~(0, j)~ to the adjacent cell $(0, j+1)$ ~(0, j+1)~ since the latter exists. (The halt command is not strictly necessary here as the program terminates anyway.)

Statement

You should submit a program in the odometer's own language, as described above, that makes the odometer behave as expected. Each subtask (see below) specifies a behaviour the odometer is required to fulfill and the constraints the submitted solution must satisfy. The constraints concern the two following matters.

Program size — the program must be short enough. The size of a program is the number of commands in it. Label declarations, comments and blank lines are not counted in the size.
Execution length — the program must terminate fast enough. The execution length is the number of performed steps: every single command execution counts as a step, regardless of whether the command had an effect or not; label declarations, comments and blank lines do not count as a step.

In Example 1, the program size is $4$ ~4~ and the execution length is $4$ ~4~. In Example 2, the program size is $6$ ~6~ and, when executed on a grid with a single pebble in cell $(0, 10)$ ~(0, 10)~, the execution length is $43$ ~43~ steps: right, $10$ ~10~ iterations of the loop, each iteration taking $4$ ~4~ steps (pebble davinci; border davinci; move; jump leonardo), and finally, pebble davinci and halt.

Subtask 1 [9 points]

At the beginning there are $x$ ~x~ pebbles in cell $(0, 0)$ ~(0, 0)~ and $y$ ~y~ in cell $(0, 1)$ ~(0, 1)~, whereas all the other cells are empty. Remember that there can be at most $15$ ~15~ pebbles in any cell. Write a program that terminates with the odometer in cell $(0, 0)$ ~(0, 0)~ if $x \le y$ ~x \le y~, and in cell $(0, 1)$ ~(0, 1)~ otherwise. (We do not care about the direction the odometer is facing at the end; we also do not care about how many pebbles are present at the end on the grid, or where they are located.)

Limits: program size $\le 100$ ~\le 100~, execution length $\le 1\,000$ ~\le 1\,000~.

Subtask 2 [12 points]

Same task as above but when the program ends, the cell $(0, 0)$ ~(0, 0)~ must contain exactly $x$ ~x~ pebbles and cell $(0, 1)$ ~(0, 1)~ must contain exactly $y$ ~y~ pebbles.

Limits: program size $\le 200$ ~\le 200~, execution length $\le 2\,000$ ~\le 2\,000~.

Subtask 3 [19 points]

There are exactly two pebbles somewhere in row $0$ ~0~: one is in cell $(0, x)$ ~(0, x)~, the other in cell $(0, y)$ ~(0, y)~; $x$ ~x~ and $y$ ~y~ are distinct, and $x+y$ ~x+y~ is even. Write a program that leaves the odometer in cell $(0, \frac{x+y}{2})$ ~(0, \frac{x+y}{2})~, i.e., exactly in the midpoint between the two cells containing the pebbles. The final state of the grid is not relevant.

Limits: program size $\le 100$ ~\le 100~, execution length $\le 200\,000$ ~\le 200\,000~.

Subtask 4 [up to 32 points]

There are at most $15$ ~15~ pebbles in the grid, no two of them in the same cell. Write a program that collects them all in the north-west corner; more precisely, if there were $x$ ~x~ pebbles in the grid at the beginning, at the end there must be exactly $x$ ~x~ pebbles in cell $(0, 0)$ ~(0, 0)~ and no pebbles elsewhere. The score for this subtask depends on the execution length of the submitted program. More precisely, if $L$ ~L~ is the maximum of the execution lengths on the various test cases, your score will be:

$32$ ~32~ points if $L \le 200\,000$ ~L \le 200\,000~;
$32 - 32 \log_{10}(\frac{L}{200\,000})$ ~32 - 32 \log_{10}(\frac{L}{200\,000})~ points if $200\,000 < L < 2\,000\,000$ ~200\,000 < L < 2\,000\,000~;
$0$ ~0~ points if $L \ge 2\,000\,000$ ~L \ge 2\,000\,000~.

Limits: program size $\le 200$ ~\le 200~.

Subtask 5 [up to 28 points]

There may be any number of pebbles in each cell of the grid (of course, between $0$ ~0~ and $15$ ~15~). Write a program that finds the minimum, i.e., that terminates with the odometer in a cell $(i, j)$ ~(i, j)~ such that every other cell contains at least as many pebbles as $(i, j)$ ~(i, j)~. After running the program, the number of pebbles in each cell must be the same as before running the program. The score for this subtask depends on the program size $P$ ~P~ of the submitted program. More precisely, your score will be:

$28$ ~28~ points if $P \le 444$ ~P \le 444~;
$28 - 28 \log_{10}(\frac{P}{444})$ ~28 - 28 \log_{10}(\frac{P}{444})~ points if $444 < P < 4\,440$ ~444 < P < 4\,440~;
$0$ ~0~ points if $P \ge 4\,440$ ~P \ge 4\,440~.

Limits: execution length $\le 44\,400\,000$ ~\le 44\,400\,000~.

Implementation Details

You will have to submit a single file containing programs to all subtasks. You will need to include headings (lines of code) of the form [Subtask X] to indicate the start of your program for subtask $X$ ~X~. When evaluating a test case in subtask $X$ ~X~, the grader will attempt to find a line containing [Subtask X] and will parse your program beginning on the next line and ending at the next subtask heading or at the end of the file.

For each test case, you will receive feedback on the resources used by your code. If the code is not syntactically correct and thus impossible to test, you will receive information on the specific syntax error. If you do not include a program for any given subtask, the subtask will score zero for that submission.

Example 3

[Subtask 1] # heading for the first subtask
right
move
move
[Subtask 4]
put

Above is an example of a submission that has valid headings and programs for subtasks 1 and 4. Note that code size is measured separately for each subtask. The above program would have code size $3$ ~3~ for Subtask 1 and code size $1$ ~1~ for Subtask 4.

Simulator

For testing purposes, you are provided with an odometer simulator, which you can feed with your programs and input grids. Odometer programs will be written in the same format used for submission (i.e. the one described above), but without subtask headings.

Grid descriptions will be given using the following format: each line of the file must contain three numbers, $R$ ~R~, $C$ ~C~, and $P$ ~P~, meaning that the cell at row $R$ ~R~ and column $C$ ~C~ contains $P$ ~P~ pebbles. All cells not specified in the grid description are assumed to contain no pebbles. For example, consider the file:

0 10 3
4 5 12

The grid described by this file would contain $15$ ~15~ pebbles: $3$ ~3~ in the cell $(0, 10)$ ~(0, 10)~ and $12$ ~12~ in the cell $(4, 5)$ ~(4, 5)~.

You can invoke the test simulator by calling the program simulator.py, passing the program file name as an argument. The simulator program will accept the following command line options:

-h will give a brief overview of the available options;
-g GRID_FILE loads the grid description from file GRID_FILE (default: empty grid);
-s GRID_SIDE sets the size of the grid to GRID_SIDE $\times$ ~\times~ GRID_SIDE (default: $256$ ~256~, as used in the problem specification); usage of smaller grids can be useful for program debugging;
-m STEPS limits the number of execution steps in the simulation to at most STEPS;
-c enters compilation mode; in compilation mode, the simulator returns exactly the same output, but instead of doing the simulation with Python, it generates and compiles a small C program. This causes a larger overhead when starting, but then gives significantly faster results; you are advised to use it when your program is expected to run for more than about $10\,000\,000$ ~10\,000\,000~ steps.