A Classic Construction Problem

Another week, another Riddler. The question:

Consider four towns arranged to form the corners of a square, where each side is 10 miles long. You own a road-building company. The state has offered you $28 million to construct a road system linking all four towns in some way, and it costs you $1 million to build one mile of road. Can you turn a profit if you take the job?

Extra credit: How does your business calculus change if there were five towns arranged as a pentagon? Six as a hexagon? Etc.?

After a few napkin drawings I landed on this shape:


Then I set up this series of equations:


Plugging that into Python we get answer of 27.3205 miles of bridges with an x_1 distance of 2.887.


Pretty simple but fun!



Camel Up Cup 2k18

Get ready for the premier bot creation board game tournament of the year!

Here’s the plan: A bunch of people make a bot to play the board game Camel Up. Then in a battle of wits we get together and pit our bots against one another. The winner will get a trophy. This is somewhat similar to Halite except way less competitive and no one will get a job as a result


The game

The game itself:

– The game is called CamelUp. I own a copy and can lend it out to try. There is also a copy at Cafe Mox in Ballard and maybe one at RayGun in Cap Hill
How to play: this video does a pretty good job of explaining how to play the game. Its five minutes
– We will playing the game with four players (bots) in each round. Player ordering and stuff will be figured out later. Only points will be awarded to the winning player


Rendering of trophies

The bot details:

– We are using Python 3.x
– Your bot will be a function that I will pass the player number and gamestate to. Using that you should return your action
– I may be patching the game leading up to the event. It should just be for bugs / things I’ve missed. Hopefully nothing crazy though. Let me know if you something

Please invite anyone! Teams are cool! Reach out with questions.

The API can be found here



Example of a player action


This was a project designed to make a functional kaleidoscope and as a use case for learning how to use a lathe. It took a few revisions to get the scale and dimensions correct but the result is one that I am pretty proud of



An exterior and interior of a Rev C kaleidoscope



Looking through one

Link to build pics

Cat in a Box

Another week, another puzzle. This one comes from MindYourDecisions on YouTube as suggested by a friend. Here’s the problem:


While I was able to logic out a solution that would find the cat in 7 steps the program I wrote was able to do it in 6. That solution is:

#Round 0 I select box 2
#Possible boxes the cat can be in: [1, 0, 1, 1, 1]
#Round 1 I select box 3
#Possible boxes the cat can be in: [0, 1, 0, 1, 1]
#Round 2 I select box 4
#Possible boxes the cat can be in: [1, 0, 1, 0, 1]
#Round 3 I select box 4
#Possible boxes the cat can be in: [0, 1, 0, 0, 0]
#Round 4 I select box 3
#Possible boxes the cat can be in: [1, 0, 0, 0, 0]
#Round 5 I select box 2
#Possible boxes the cat can be in: [0, 0, 0, 0, 0]

The benefit of this program is that it is easily able to find solutions for cases where there are more than five boxes, the cat can move one or two, etc.

Of course his explanation was cleaner but its a little nice to be able to say you exhaustively searched all the cases 🙂

import random
import copy
def select_box(sel_box,boxes):
#Input a box, it does the proceeding logic
old_boxes = copy.deepcopy(boxes)
for i in range(0,len(boxes)):
if old_boxes[i] > 0:
if (i>0) : boxes[i-1] += 1
if (i 0) for x in boxes] #reduces all non-zero box values to one
return boxes

def print_history(path,box_hist):
for i in range(0,len(path)):
print("Round " + str(i) + " I select box " + str(path[i]+1)) #plus one because the problem uses 1-indexing
print("Possible boxes the cat can be in: " + str(box_hist[i]))

def find_path(thresh):
#set base values
boxes = [1,1,1,1,1] #A 1 indicates the cat can be in the box
min_cat_spots = len(boxes)
path = []
box_hist = []

#Select a random box, check state after each selection. Repeat until finished or it won't work
while min_cat_spots !=0 and len(path) < thresh:
selection = random.randint(0,len(boxes)-1)
boxes = select_box(selection,boxes)
cat_spots = sum(boxes)
if cat_spots < min_cat_spots:
min_cat_spots = cat_spots
return [len(path),path,box_hist]

#Search for paths while the the search has a chance to be the new low-score
thresh = 14 #any large number
for i in range(0,10000):
results = find_path(thresh)
if results[0] < thresh:
thresh = results[0]


Rescuing the Paratroopers

Another week, another Riddler. The question:

During their descent, three paratroopers were blown off course and crash-landed in the desert — an infinite, uniform, two-dimensional plane. They come to at a random time after the crash and must find a way to meet up. The only tool they each have is a device that displays a snapshot of the positions (but not the velocities) of all three of them in the desert. They can each use this tool only once. To make things more annoying, they’ve all been nearly blinded by sandstorms and won’t be able to physically see the others until they’ve all arrived at the same point.

Can you devise a strategy that they can agree upon beforehand and that will guarantee they will meet up? (Note that the snapshot does not indicate the specific identities of the other paratroopers, so a strategy like “let’s agree that A stands still and B and C walk to him” will not work.)

Extra credit: Is there a strategy that would work for any number of paratroopers?

Here is the strategy I devised: Everyone gets to decide their unique walking velocity — the only thing that matters is that everyone’s speed is different than the others. Then we will, when we wake up, draw a circle that is constrained by the three points of our buddies (including ourselves). This represents the path that we will walk at our set velocity in a set direction (say, clockwise). Then as we walk if another person were to wake up they would inevitably draw the same circle and embark along the same path, eventually running into one another. If we meet up we will stay exactly where we met. The third person will either be on the same path or wake up and see that the other two have met and make a bee line for the group of two.


Example of path determined by a snapshot

Extrapolating this to more people, we just make a closed shape that has as many variables as there are people. For four we can use an ellipse with horizontally constrained foci, for five we can use an ellipse with unconstrained foci, etc.


Example of a path made with four people

In the case with more than three people if two meet they continue to move along their path. Anyone who wakes up after two have met will again just make a bee line for where ever the two person group is at that time, knowing they will be collected at the next revolution. This should work for all cases.