TV-aksjonen 2025

Collection route

We've been doing some door-to-door walking and written down the route we took. We're going to make a report of it, but it looks like others have been writing down their routes there too and ours is kind of hard to make out. The file with the route is here.

Here's a similar but smaller example:

┌┐──┌┐│┌┐┌┌┐┌┐┌┐┌┐┌┐┌┐└─┌┐─│┌──┐┌└─┌┐─┌┐
┌└──┘└┘││└┘││││└┘└┘│││┌─┘└──┘┌┐│└┐┌┘└─┘│
│┐┌→───┘└┐┌┘│└┘│┌─│││└┘┌─┌┐┌┐┌┘│┌└┘┌─┐┌│
││└┐┌─┐─┐││┌┘┌─│└┐│└┘│┌┘┌┘│┌┘│││└──│││││
│┌─┘┌─│┌┘│││┐└─┘││└──┘└┐│┌┘└┐││└┐│┌┘│└┐│
┌┘───┐││─└─┘└┐└┐┐└┐┌───┘│└─┐│└┘││┌┘┌┘─└┐
└───┐└┘└─┐└─┐│─┘│┌┘└────┘─│││──┐└┘│└─┐││
│─┌│└──┐┌┘│┌┘│┌┐││┌┐──┌───┐│└┐┌┘┌││──└┐│
└┐└─┐┌─│└┐└┘┐└┘││└┘└─┐└┐┌─└┘│└┘┌┘│└───┘│
┌┘└─└┘┌┘││┌┐└─┌┘└┐──┐│││┌──┐││┌┘┌──────│
└─┌───┘─│││└─┌┘┐─└──┘└┐└┘┌─┘└─┘┌│┌─────┘
┌─┘─────┘││┌─┘─┘┌┐┌─┐┐└┐┌┘┌──┌─┘│└────┐┐
│───┐│┌┐┌┘│└────┘││┌┘└┐│││┌─┐│┌─└┐└─┐│││
└┐└┐│└┘││┌┘┌┐┌───└┐│┌─│└┘│││└┘└──┘┌┐│┌┘│
┌└┐│└─┐┌┘│┌┐└┘┌┌┐│└┘└┐└──┘│─┌───┐┌┘└┐└─┐
└┐│└─┐│││││└┐─┘││┌─┐┌┘─┌──└─┘┌┐│└┘┌┐└─┌┘
┌┘│┌┐│└┘││└─┘┌┐││└─┘│┐┌──┐─┐─│└┐│┌┐└─┌┘│
└┐└┘│┌─┐│└───┘││└┐┌─┘││┌┐│─└─┐│└┘││┌─┘││
│└┐││││└┐┌─┐┌──┘┌││┌─┐│┌┘│┌─┐└──┌┘└┘┌┐││
└─└┘└┘└─└┘─└┘───┘└─┘─└┘└─└┘│└───┘───┘│└┘

We know that we made an arrow when we started our walk and that we returned to where we started at the end. Here's the example with our walk highlighted:

┌┐──┌┐│┌┐┌┌┐┌┐┌┐┌┐┌┐┌┐└─┌┐─│┌──┐┌└─┌┐─┌┐
┌└──┘└┘││└┘││││└┘└┘│││┌─┘└──┘┌┐│└┐┌┘└─┘│
│┐┌→───┘└┐┌┘│└┘│┌─│││└┘┌─┌┐┌┐┌┘│┌└┘┌─┐┌│
││└┐┌─┐─┐││┌┘┌─│└┐│└┘│┌┘┌┘│┌┘│││└──│││││
│┌─┘┌─│┌┘│││┐└─┘││└──┘└┐│┌┘└┐││└┐│┌┘│└┐│
┌┘───┐││─└─┘└┐└┐┐└┐┌───┘│└─┐│└┘││┌┘┌┘─└┐
└───┐└┘└─┐└─┐│─┘│┌┘└────┘─│││──┐└┘│└─┐││
│─┌│└──┐┌┘│┌┘│┌┐││┌┐──┌───┐│└┐┌┘┌││──└┐│
└┐└─┐┌─│└┐└┘┐└┘││└┘└─┐└┐┌─└┘│└┘┌┘│└───┘│
┌┘└─└┘┌┘││┌┐└─┌┘└┐──┐│││┌──┐││┌┘┌──────│
└─┌───┘─│││└─┌┘┐─└──┘└┐└┘┌─┘└─┘┌│┌─────┘
┌─┘─────┘││┌─┘─┘┌┐┌─┐┐└┐┌┘┌──┌─┘│└────┐┐
│───┐│┌┐┌┘│└────┘││┌┘└┐│││┌─┐│┌─└┐└─┐│││
└┐└┐│└┘││┌┘┌┐┌───└┐│┌─│└┘│││└┘└──┘┌┐│┌┘│
┌└┐│└─┐┌┘│┌┐└┘┌┌┐│└┘└┐└──┘│─┌───┐┌┘└┐└─┐
└┐│└─┐│││││└┐─┘││┌─┐┌┘─┌──└─┘┌┐│└┘┌┐└─┌┘
┌┘│┌┐│└┘││└─┘┌┐││└─┘│┐┌──┐─┐─│└┐│┌┐└─┌┘│
└┐└┘│┌─┐│└───┘││└┐┌─┘││┌┐│─└─┐│└┘││┌─┘││
│└┐││││└┐┌─┐┌──┘┌││┌─┐│┌┘│┌─┐└──┌┘└┘┌┐││
└─└┘└┘└─└┘─└┘───┘└─┘─└┘└─└┘│└───┘───┘│└┘

If we count the highlighted tiles, we get 216. That's the length of our walk. We want to find the length of the larger, actual walk.

Below is various example code. It's possible to solve the puzzle by implementing the rest of the step and solve functions. Or you can take some other approach :)

Show Me The Code!

// we have the example:
// and also the full text
          
const examplemap = read(example);
const fullmap = read(text);

print(`example: ${examplemap.size}, full: ${fullmap.size}`);

// example and full text have the same start position:
const start = point(3, 2);
print([start, examplemap.get(start)]);
print([start, fullmap.get(start)]);

// there's the functions N, S, E, W, for adjacent positions:
// there's the functions N, S, E, W, for adjacent positions:
const positions = [start];
for (let i = 0; i < 5; i++) {
    positions.push(E(positions.at(-1)));
}
print(positions);
print(positions.map(p => examplemap.get(p)));

// it's possible to paint over parts of the map with set
examplemap.set(start, "X");
printmap(examplemap);

// some potentially useful characters and relations between them:
const startchar = "→";
const north = { forward: "│", left: "┐", right: "┌" };
const east = { forward: "─", left: "┘", right: "┐" };
const south = { forward: "│", left: "└", right: "┘" };
const west = { forward: "─", left: "┌", right: "└" };

// tip: try solving for example first
// and then use the same code on the full thing

const step = (map, state) => {
    const pos = state.pos;
    const dir = state.dir;
    const c = map.get(pos);
    return { pos: E(pos), dir: north };
};

// test the step function:
const examplestart = { pos: start, dir: east };
print(examplestart);
print(step(examplemap, examplestart));

const solve = (map) => {
    // set an inital state
    // let state = { pos: ..., dir: ... };

// answer is less than a million
    // so avoid infinite loop by stopping there
    for (i = 1; i < 1000000; i++) {
        // update the state
        // maybe check an end-condition and return i
    }
    return i;
};

print(solve(examplemap));
// if it gets the correct answer for the example
// it _should_ get the correct answer for the full map as well:
// print(solve(fullmap));

Output

Submit Your Solution

What is the length the walk we documentet in the provided file?

Not logged in. You must sign up or log in before you can submit your solution!