Prev: The Perfect Shuffle Problem

The Code

Both Java and Ruby based solutions to the Perfect Shuffle Problem are available for download below. In addition to comparing styles, they are informative for anyone learning Ruby with a Java background, or vice versa.

The Java based solution is 82 lines of code, while the Ruby version is 76 lines. Not a huge discrepancy. The character count is quite different though: 1,943 (Java) versus 1,615 (Ruby). Looking at the two code excerpts, we see why.

The Java program’s main loop is shown below.

private long getNumPerfectShuffles() {
int pos = 0;
long totalShuffles = 1;
while( (pos = getFirstUnvisited(pos) ) < _visited.size() ) {
long shuffles = 0;
do {
_visited.set(pos, true);
pos = shuffle(pos);
++shuffles;
} while (!_visited.get(pos));
totalShuffles = lcm(totalShuffles, shuffles);
}
return totalShuffles;
}

If you are used to programming with Java, the verbose aspects of the above code above may not be obvious to you, such as

• Explicit type declarations.
• Static typing.
• Mandatory parenthesis after method names.
• Mandatory semicolons on each line.

Comparing the preceding Java code to the equivalent Ruby snippet makes the verbosity of Java more obvious.

def get_num_perfect_shuffles
pos = 0
total_shuffles = 1
while (pos = get_first_unvisited pos) < @visited.size
shuffles = 0
begin
pos = shuffle pos
shuffles += 1
end while !@visited[pos]
total_shuffles = lcm(total_shuffles, shuffles)
end
return total_shuffles
end


What I Think

I like the Ruby version more.

I don't care about static typing. The static typing in Java does prevent some bugs. Also I admit that to do any serious development with Ruby I use a unit testing framework. But I've found static typing to prevent only a small minority of bugs, and not even those particularly challenging. So I still need to use unit tests with Java anyways.

I also like not having to place parenthesis, braces and semicolons all over the place.

while (pos = get_first_unvisited pos) < @visited.size
shuffles = 0

will always be easier for me to read than

while( (pos = getFirstUnvisited(pos) ) < _visited.size() ) {
long shuffles = 0;


When Ruby is explicit, I feel it gets it right. Note that in the java version I place an underscore at the beginning of _visited to remember it is an instance variable. That's just my technique. With Ruby, this convention is formally enforced with an at character. So the @ denotes @visited is an instance variable.

Finally, with the above two code snippets I did not even touch upon the deeper features unique to the Ruby language, such as blocks and metaprogramming. Such features have no practical significance in solving The Perfect Shuffle Problem though.

Conclusion and Download

But my preference for Ruby is simply that: my preference. I didn't write this article to convert you into Ruby believer. I hope you will compare and contrast Java and Ruby for yourself.

Please download the Java version here: http://abettermanual.com/wp-content/uploads/2009/09/PerfectShuffle.java

The Ruby version is available here: http://abettermanual.com/wp-content/uploads/2009/09/perfect_shuffle.rb

I hope you found this series of articles informative. I welcome your feedback. Good luck with all your programming endeavors.

Prev: Introduction

The Perfect Shuffle Problem

The Perfect Shuffle Problem involves determining how many shuffles are required to return a deck of cards to its original order . The following is a formal definition from halfbaked.net.

Given a deck of nCards unique cards, cut the deck iCut cards from top and perform a perfect shuffle. A perfect shuffle begins by putting down the bottom card from the top portion of the deck followed by the bottom card from the bottom portion of the deck followed by the next card from the top portion, etc., alternating cards until one portion is used up. The remaining cards go on top. The problem is to find the number of perfect shuffles required to return the deck to its original order.

Your function should be declared as:

static long shuffles(int nCards,int iCut);

What is the result of shuffles(1002,101)?

We need to conceptualize what we are going to solve, and we are not going to do that thinking about a 1002 card deck and a 101 card cut. Most of us are familiar with a 52 card deck. But even shuffling 52 cards is difficult to visualize. So, let’s first investigate how many perfect shuffles are required to bring a 6 card deck with a 2 card cut to its original order.

The initial position of the cards is shown in the following image. I number the cards 1 through 6. I also number the position of the cards, 1 through 6. So the original position of cards 1 – 6 is positions 1 – 6 respectively.

If we perform a two card cut, we end up with two stacks of cards. One stack contains cards 1 and 2, and the other contains 3 – 6. Performing a perfect shuffle on these yields the descending card order 3, 4, 1, 5, 2, 6. Another perfect shuffle brings us 1, 5, 3, 2, 4, 6.

The third perfect shuffle renders 3, 2, 1, 4, 5, 6. The fourth 1, 4, 3, 5, 2, 6.

The fifth shuffle leads to the order 3, 5, 1, 2, 4, 6. Finally, the sixth shuffle returns the cards to their original positions.

Brute Force Solution

So six cards with a cut of two cards needs six shuffles? Not too bad. At this point you may be tempted simply use a brute force implementation.

The pseudo-code for the brute force implementation is straightforward.

1. Initialize each card Ci in deck D to position i.

2. Shuffle deck D.

3.Until each card Ci is in its original position i:
increment shuffle count,
shuffle again (2).

Such a method works fine for six shuffles. However, if you try to use brute force to solve 1001 cards with a cut of 101, which I encourage you to do, you will quickly find it doesn’t work. Or well, you’ll slowly find it doesn’t work — it takes too long. Your brute force program will need to shuffle the deck 5,812,104,600 times! With each shuffle your program manipulates and investigates an array of 1001 elements. So, the brute force solution is of the order C × S, where C is the number of cards in the deck, and S is the number of shuffles required. We need to improve upon C × S.

There is no way to reduce C. In other words, there is no magic formula to determine where a card will be after shuffling it, without shuffling it. There is a way to improve upon S however.

Cycle Based Solution

Understanding the improved solution requires that we observe the way each card shuffles within the deck. Look at what happens to card 1 during the first two shuffles in the example above.

The first obvious conclusion is that card 1 returns to position 1 after the second shuffle. The second conclusion is less obvious but key to improving upon the brute force algorithm: any card in position 3 will return to it’s original position after two shuffles as well. That’s because card 1 passes through position 3, and shuffling by definition is the exchange of one card’s position with another. Looking at the image again, we see that card 3 is indeed back at it’s original position after two shuffles

For a slightly more complicated example, look at card 2 above. It visits position 5, then 4, then returns to position 2 on the third shuffle. Given the cyclical nature of shuffling we expect cards 5 and 4 to return to their initial locations after three shuffles as well. Indeed they do.

We have looked at cards 1 – 5. The final card, 6 remains in place throughout. In other words, it is at its original position after only one shuffle.

So, some of the cards require two perfect shuffles, some require three, and one card requires one. To determine the number of shuffles required for the entire deck, we simply find the lowest common multiple of these, which is six.

Now we have a way to determine the number of perfect shuffles required by examining the deck on a card by card basis. We need to look at each card position once, and only once. The pseudocode is below.

1. Intialize each card Ci in deck D to position i.

2. Until Ci is in position i:
shuffle Ci to new position j,
increase shuffle count,
mark j as visited.

3. Record the shuffle count at all visited positions.

4. Repeat shuffle process (2) for the next Ci
where i has not been visited.

5. When we have visited each position:
calculate total perfect shuffles required which is
the lowest common multiple of shuffles required for every Ci.

Again, this new algorithm requires that each position in the deck needs to be investigated only once. We need to shuffle the deck C times and therefore our new order of complexity is simply C, a major improvement.

But we need to implement our algorithm. In the next post I’ll provide both Java and Ruby code to do just that.

Next: The Code

Introduction

I once read a comparison of Java and Ruby that said, “Ruby is terse, Java is not.” And that was it.

OK thanks. I’ve read equally uninformative statements about English and Japanese. Such generalizations do not answer my main concern as a developer, which is why and when to use either language.

A more educational way to compare the two languages is to write a Java and Ruby program to solve the same challenging problem. Ideally, the problem’s solution would be relatively short.

Therefore, in part 2 of this article I describe the Perfect Shuffle Problem, and how to solve it without using brute force. I follow this up in part 3 by presenting both a Java and Ruby based solution.

If you are impatient to get to the comparison, feel free to skip to Part 3.

Next: The Perfect Shuffle Problem

Someone told you installing Mint was straightforward. Someone was right. I tell you installing and configuring Mint for WordPress is more straightforward. I am more right.

Below I show you why. And how.

Uploading Mint To Your Web Host

The first step is to download the latest mint archive from  haveamint.com.

Next, log into your web host. Access the File Manager from the cPanel.

Using the File Manager, upload the archive to your host. Then extract it, and move the “mint” folder to yourdomain.com/mint. In my case, I moved the mint folder to abettermanual.com/mint.

Now you need to add your database information to mint/config/db.php. Luckily WordPress stores all of the information you need in wp-config.php. By default wp-config.php is in the root directory of your domain. View wp-config.php and take note of the the following:

• The server.
• The username.
• The password.
• The database.

Now edit mint/db.php and insert the information recorded from wp-config.php.

Now you’re done with the hard part. The rest of the directions discuss configuration.

Configuring Mint

Point your browser to http://yourdomain.com/mint. You’ll see the Mint End User License Agreement page.

After you accept the terms of the EULA, the next screen will aks you to enter your activation key. The page after that lists various configuration parameters, as shown below. For now, leave “Ignore my visits (uses cookies)” unchecked. You will want to use your visits for testing later. After testing, I’ll show you how to ignore them.

Finally, you are brought to a screen instructing you to manually insert code. You can ignore those instructions. Below I show you how to install the Micro Mint plugin. It makes manually inserting code unnecessary.

Installing Micromint Plugin

The Micromint Plugin inserts mint tracking code for you. It vastly simplifies your life when you decide to change WordPress themes, for example. But first you need to install it.

Start from the WordPress dashboard. In the left sidebar, select Plugins -> Add New. Then enter “micromint” in the text box and click “Search Plugins” to find the plugin. Finally, click on the “install” link.

When the installation completes, select Settings -> µMint. Check the box next to “Track Stats,” and ensure the Mint Location is correct. After that, click “Mintify.”

You’re done! Next we’ll verify that everything works.

Testing 1, 2, 3

Open up a new browser window, and go to your WordPress website. Then, in a separate window go to http://yourdomain.com/mint. You should see your visits listed there. Refresh both your WordPress site and your mint page a few times for a more thorough verification.

Now you probably want to ignore visits from your own computer. To do that, first click on preferences.

Then check the box next to “Ignore my visits (uses cookies).”

That’s it! Now Mint will keep you up to date with visitor information, and ignore visits from your computer.

You’ll need to install some Pepper to enable Mint to display detailed user demographics. In a future post I’ll describe how to do that.

WordPress features an automatic upgrade option since version 2.7, which apparently often works. Great. But what if it doesn’t work? Or what if you manually installed a prior version?

The detailed WordPress manual upgrade instructions inform you that indeed, you don’t want to perform a manual upgrade. So you feel stuck with say, Wordpress 2.3.2. And you are depressed.

Actually, you are merely a few clicks away from an up-to-date Wordpress installation. I show you what to do, below.  I do however make one assumption: your web host features SimpleScripts. Most do.

Life Improvement Through Software Import

First, we will import your manual installation to SimpleScripts. The entire process can be carried out via the SimpleScripts dashboard.

The first step is to locate the SimpleScripts button in your host’s cPanel.

Then find the WordPress link.

In the WordPress menu, click on the “Import” button.

Once on the import page, you’ll see two import options. One is to import from a manual installation. Enter the url of your manual installation in the text box.

If everything went well, your imported installation is listed as shown below. Now your WordPress installation is managed by Simple Scripts.

Next is the fun part: upgrading to the latest and greatest WordPress.

Life Improvement Through Software Upgrade

Under your installation listing, click on “Upgrade Available.”

At the upgrade page, be sure to read carefully where it says “Read Carefully!”

It would be prudent to follow the listed precautionary steps. Certainly you want to deactivate your plugins. Backups are good, too.

When you’re ready, agree to the legal terms and click on “Upgrade Now.”

Back at the SimpleScripts page, your newly updated WordPress installation will be listed.

Now is a good time to log in to the WordPress dashboard, activate your plugins, and make sure your blog looks right. If not, you will need to restore from backup, or tweak a few files. I never had any problems with an upgrade, though.

You’re almost done. In fact, maybe you are done. But most likely the automatic upgrade did not bring you to the latest version of WordPress since you imported from a manual installation, and the “Upgrade Available” link is still shown.

So, now you can again deactivate your plugins, and iteratively upgrade using Simple Scripts. First click on “Upgrade Available,” and then repeat the previous upgrade process. To be extra safe, you can activate your plugins, make sure your blog looks good, then deactivate your plugins each time.

Finally, your WordPress installation will be up to date, with no upgrade option shown.

Now you have the latest version of WordPress. Awesome! I recommend logging in to WordPress and checking out some of the new features.

If you are looking for a WordPress installation guide, you found it. And if you’re on the fence about hosting and self-installation, this guide illustrates the simplicity of the process.

Why To Do It

Hosting your own blog costs money. It also requires technical skill. So, why host a blog yourself rather than using say, blogger.com?

In short, hosting is the best choice if you want to:

• Completely control of the look and feel of your site.
• Maximize the monetization of your content.

For a more detailed analysis, an excellent article is on Don Campbell’s site.

How To Do It

The first time I installed WordPress, I followed the manual installation instructions on their site. The pain of the corresponding upgrades meant manually installing WordPress wasn’t the best choice. You’ll understand what I mean if you check out these instructions for upgrading a manual installation.

Luckily there is an alternative: SimpleScripts. In addition to automating the initial install, SimpleScripts will upgrade WordPress with a few clicks of the mouse.

To install Wordpress with SimpleScripts, first access the SimpleScripts menu from your web host’s cPanel.

Then click on the WordPress link.

From there click on “Install.”

That’s it. You’re done.

To check out your installation in the future, you can again access the SimpleScripts dashboard from the cPanel. When a WordPress upgrade is available, SimpleScripts will display a red link. Click on it to keep your WordPress up-to-date.

Simple, right? Now you are part of the WordPress community.

The next step is to upload some quality content to your new blog. I look forward to reading it.