How many permutations are there in such that for all ?

For that problem, the answer was . The number of permutations on items where no item moves more than one space from where it started is the -th Fibonacci number. Now, the obvious question is: How many permutations are there in such that for and is an arbitrary positive integer?

Let’s not start so arbitrary just yet though…

Let’s just look for a moment at how much trickier things become when we let . It’s easy enough for . There’s only one shuffle possible and it satisfies the constraint. For that matter, the same is (conventionally) true for . When you have zero items, there is only one (very Zen) way to shuffle them, and it certainly does not violate the constraints.

For , there are two shuffles. Both satisfy the constraints. Similarly, with , there are shuffles. All of them satisfy the constraints.

For , we get to the first interesting case. Here, some of the shuffles violate the constraints. So, how many shuffles are still possible? To tackle this, we are going to use an inclusion-exclusion counting. The only items that could be out of place are the first and the last. So, how many of the shuffles have either the first element move to the back or the last element move to the front?

There are permutations that send the first element to the back. There are permutations that send the last element to the front. We might then think that there are valid shuffles. Alas, there are some shuffles that move both the first element to the back and the last element to the front. We have counted those twice. There are of those.

So, for , there are shuffles satisfying our constraint that .

What then of ? Well, it’s bedtime here. This is gonna have to wait.

Goodnight.

One nascent game concept that I have in my head requires me to do some constrained shuffling. As an example constraint, imagine that you need to shuffle a deck of cards while ensuring that no card moved more than five spots away from where it started. Or, imagine that you had to shuffle the deck so that a card of rank could only move to spot that had been held by a card of rank , , or .

In the general case, you have a directed graph with vertexes and a permutation such that can only equal if there is an edge in the graph from to .

Well, as this is for a game, it would get pretty boring if there were only a few possible shuffles. On the other hand, if there are a large number of possible shuffles, then I haven’t really restricted the shuffling at all for all practical purposes. So, then the question is: for a given directed graph, how many possible shuffles are there? Can I generate them without generating any of the invalid permutations, too?

Today, I started with the How many?-question. I started with a very simple graph. The vertexes are spaced evenly along an east-west line. Each vertex is connected only to itself, its nearest neighbor to the east, and its nearest neighbor to the west. Put another way, for .

Let’s say we already had a row of vertexes. If we add another vertex at the beginning of the row, then there are two things that a shuffle can do to that new vertex: leave it where it is or swap it with what had been the first vertex in the row. Now, suppose that is the count of valid shuffles for vertexes in this configuration. The case where our new vertex stays where it is leaves possibilities for the rest of the row. The case where our new vertex swaps places with the old first vertex leaves possibilities. As such, .

Cha-ching. Note that and , then where are the Fibonacci numbers.

Things get a great deal messier if we move up to . More on that some other time…

I needed a weighted random choice in two different places, and I implemented it differently in each place. Weird, right? Even weirder, I think I did the right thing in each place.

Picking a card from a deck

In the first case, I needed to choose a flash card from a deck. I want to favor cards that have given the player trouble in the past. I zip through the list once to sum up the weights. Then, I pick a random number greater or equal to zero and less than the sum of the weights. Then, I run through the list again summing the weights until my running sum exceeds my random number. (Here in Perl, um, for clarity?):

my $total = 0.0;
foreach my $item ( @list_of_items ) {
    $total += weight( $item );
}
 
my $thresh = rand( $total );
my $found;
 
foreach my $item ( @list_of_items ) {
    $thresh -= weight( $item );
    if ( $thresh < 0.0 ) {
        $found = $item;
        last;
    }
}

This requires that the weight() of a given item remains constant for the duration of the function. The weight() can change between choices, however. If the weight() will remain constant for large portions of the program then you can cache the total and only bother with the second half of the loop.

Choosing a letter of the alphabet

In a different portion of the program, I need to make random letter tiles. I feel like there should be more E‘s than Q‘s. I also want to leave a pathway to use the same artwork for different languages. Because of all of this, I opted to have the weights to come in from a file.

My data file is JSON encoded. I could, I suppose, do something like this (given the English letter frequencies):

{
    "english" : {
        "A": 8.167,
        "B": 1.492,
        "C": 2.782,
        ...
    }
}

But, that hurts to even think about. Instead, I opted to round them off to integer proportions. Then, I could just do this:

{
    "english": "AAAAAAAABBCCC..."
}

Now, making a random choice simply involves selecting one character from the string.

The Basic Spiral

I am talking about a simple spiral of the form:

That would be an equation for a spiral that starts at the origin and heads outward as increases. For my application though, I want to end at the origin so I need to substitute in for .

The math is also going to work out slightly better if I use in place of in the above equations:

I don’t want the piece to spiral into place when released though. So, really, I am concerned with just the coordinate from the above equations:

To normalize everything, I am going to let . And, since I want my interpolation value to go from zero to one instead of one to zero, I am again going to subtract this all from one:

Parametrizing by Arc Length

If I just plot the spiral as is, then I am stuck with the same problem that I had with damped spring motion: the frequency is constant. The rate at which it would shimmy would not increase. I want it to really settle into place. So, I have to walk through the spiral at a fixed rate. I need to rescale the into something else so that for any given time interval, I cover the same arc length on the spiral.

The first step then is to figure out how much arc length I sweep out with any given . Call this arc length :

Then, to rescale my , I want to use instead so that . So, when , for example, I will need to find the such that the arc length covered in the first seconds is -th of the arc length covered in the whole interval. Solving for in the equation comes out to:

Plugging all of that back into the equation for gives me:

You can see how the period speeds up toward the end. This was a good starting point. However, the first oscillation goes almost as far beyond the target as our initial point was. So, I upped the exponent to :

This was pretty much the effect I wanted. Unfortunately, it involves taking an -th power, an -th root, and a cosine of calculation. I decided that was close enough to one to give it a whirl without needing the -th power.

Here you can see the final result.

In the previous post, I twiddled the equations for damped spring motion until I found something visually pleasing. Last night, I went back to the drawing (a.k.a. white) board.

What if I used an exponential spiral (parameterized by arc length). Then, I could easily adjust the number of times it bounces back and forth. I could use a spiral like and where is some multiple of . Then, I could walk along the spiral getting to the origin when going around the origin times in the process. If I follow the curve at a fixed rate, then I guarantee that my oscillations will pick up speed as I approach the origin.

Rather than have it spiral into the center, I am just using the x-coordinate of the spiral as my new value to interpolate with. I like the effect for the most part. It overshoots a little bit far on the first oscillation. I may tweak it some more before it’s all over. For now though, I am sticking with it.

I will post some graphs soon.

The easiest way to do this is to just warp it to where it’s supposed to go. This isn’t very visually pleasing. The next best thing is to set up a time-interval on which it moves into place. Then, linearly interpolate from where it is to where it’s going (here with normalized to range between zero and one):

That’s much better than just warping, but it doesn’t have any sort of fade-in or fade-out. It instantaneously has its maximum velocity and then instantaneously stops at the end.

Typically, then one uses a cubic spline to scale the value before interpolating to get a speed up in the beginning and then slow down in the end.

I might like to decelerate faster than I accelerate though so I might employ a fancier (higher-order) polynomial like:

But, in this case, I wanted the tile to overshoot the target a bit and then nestle/wiggle into place. So, I experimented with a bunch of different polynomials. I was having real trouble getting them to behave in a way that felt right. So, I went back to the physics of it.

What I wanted was pretty similar to damped spring motion. Imagine you’ve tied a heavy weight to a spring and suspended it all in a jar of oil. If you perturb the weight, it will bounce up and down but
each bounce is closer to the equilibrium point than the previous bounce. (Actually, it’s more complicated than that. If the spring is too weak or the oil too viscous, the weight will just slowly return to the equilibrium point without ever going past it. That’s called overdamped harmonic oscillation. What I want is called underdamped harmonic oscillation and that’s all I will concern myself with here.) The equation for this motion is:

To get it to wiggle an appropriate amount, I was using and effectively making the cosine into a sine.

This is all well and good, but to really scale my t, I need this to start at zero and approach one. So, I was really using:

Well, now it starts zig-zagging on the way to its destination. It already starts cutting back long before it makes it to where it’s going. I needed to get close to the destination much sooner. So, I jiggered the term:

This looks terrible though. I hit the destination is less than a tenth of a second and then not again until about half a second. The reason for this is that the oscillations happen at a fixed rate. never changes and moves steadily along so that keeps the same frequency throughout my interval. So, I jiggered the going into the sine function to make my oscillations start out slowly and really speed up toward the end.

This is much better, but it still didn’t give the feeling of settling in because the second oscillation was almost as high as the first. I could up the value of and get somewhere. But, I wanted it to be even more dramatic. So, I changed the in the exponent to (and used a slightly higher : was 3 and is now 4):

This was pretty decent, but I felt the initial attack was a bit strong. So, I dropped down the exponent on my base curve from 4 to 2:

This is pretty nice. It looks pretty natural (despite making an entire mess out of damped harmonic motion). It doesn’t ease in at all though so I might still need to replace the with something of a higher order. But, I might not mind the tile achieving instant velocity. It gives it that I’m really supposed to be over there sort of urgency.