Stack Height Scoring Analysis

Competition Rules/Strategy
#1

Question: Is there an optimum stack height?

Answer: Yes, there is.

Let n represent the total number of containers
in our scoring area. For the sake of our
calculations, this is a constant value.

Let x represent the number of containers that we
use to make our stack.

Then n-x equals the number of containers in the
scoring area not used in building the stack.

Our score, excluding “king-of-the-hill” points,
can then be calculated by multiplying our stack
height by the number of containers not used in
building our stack. Creating a mathematical
expression for this we get:

score = x(n-x)
= nx-x^2
= -x^2 + nx

So the (oft quoted) quadratic coefficents are:

a=-1
b=number of containers in our alliance’s scoring area
c=number of “king-of-the-hill” points

         ** Calculus Alert **

Now to optimize our score we take the derivative
of the above equation…

score’ = -2x + n

…and then solve for x when score’ is held at zero.

-2x + n = 0
-2x = -n
x = -n/-2
x = n/2

What this expression says is that we will get the
maximum score if we use half of the available
containers in the scoring area to build our stack.

Homework question:

This falls apart if n is odd. Afterall, how do you
stack half of a container?!? So my question is simply:
Given an odd number of containers in your scoring
area, do you put that last, odd-numbered container on
the stack or not?

Hint:

Well, first you might just make a table that relates
the two possible scores for each case (n=3,5,7,etc).
Then if you’re still curious, you might want to do a
mathematical proof to convince yourself that this
still holds true for a million and one containers in
the scoring area.

-Kevin

#2

Don’t put the odd numbered container on the stack.

Technically, it doesn’t matter if you do or not. Your resulting score will be exactly the same (for example, 8 * 9 vs. 9 * 8). However, if you attempt to stack that last crate, you’re risking (a) accidentally knocking over the stack, (b) an opponent knocking over the stack when you could have been defending it, and © not releasing the crate before time expires, in which case I don’t believe it counts towards your score at all.

#3

*Originally posted by jeremyw_562 *
**Don’t put the odd numbered container on the stack.

Technically, it doesn’t matter if you do or not. Your resulting score will be exactly the same (for example, 8 * 9 vs. 9 * 8). However, if you attempt to stack that last crate, you’re risking (a) accidentally knocking over the stack, (b) an opponent knocking over the stack when you could have been defending it, and © not releasing the crate before time expires, in which case I don’t believe it counts towards your score at all. **

Excellent! This is exactly what I was looking for. Now for extra credit, how about a formal proof of this :D.

-Kevin

#4

This falls apart if n is odd. Afterall, how do you stack half of a container?!?

I dunno, as one might see in the other threads, those containers are pretty brittle… And we all know what happens when bruteforce is encorperated into a math equation…:rolleyes: :smiley:
icky, broken stuff!

Excellent! This is exactly what I was looking for. Now for extra credit, how about a formal proof of this .

You can’t! lol, But hey, isn’t that whats makes FIRST wonderful?!:smiley:

#5

The easy proof is the commutative property of multiplication, and my calculus is too rusty to do it for real. :slight_smile: Here’s my best attempt:

Given x, an odd number of containers in scoring position,
let y = the optimal stack height (which you have proofed)

y = x/2

In the case of an odd number of containers, y will be a complex fraction (where x = 11, y = 5 1/2). Since we cannot have 1/2 a container, we must round y either up or down, by adding 0.5 or subtracting 0.5.

We can calculate 2 scores based on (1) adding another container to the stack and (2) not adding another container to the stack.

s1 = (y+0.5) (y-0.5)
s2 = (y-0.5) (y+0.5)

Given the commutative property of multiplication (which states that AB=BA), we prove that s1 = s2.