This all pertains to the randomness of cards and specifically the distribution of cards when shuffled from a fresh deck. Following that, any state after that initial shuffle is harder to predict but it may still be predictable. You can view the original algorithm defined in the original post from Leepoint. However, while this example is clearly defined in the context of cards, it is not strictly deck-card based – if you need to randomize any set, using that original algorithm probably will not yield the results you are looking for. You will see why soon.

The modified version runs along these lines.

public static int[] getOriginalShuffledDeck() {
  Random rnd = new Random();
  int[] cards = new int[52];
   
  for (int i = 0; i < cards.length; i++) {
    cards[i] = i;
  }
  
  for (int i = 0; i < cards.length; i++) {
    int position = i + rnd.nextInt(cards.length - i);
    int temp = cards[i];
    cards[i] = cards[position];
    cards[position] = temp;
  }
  return cards;
}

Aside from the minor stylistic differences, the major logical difference is the in the declaration of the position. The i + rnd.nextInt(cards.length - i) changes the position properly, so that elements are not repeatedly moved around the deck of cards. I am not entirely sure of the logic here – an example chart could be useful, but I’ll leave that to you.

The other algorithm I tested against was the built-in Collections.shuffle randomization. It appears that this method is consistent with the modified method above, which is good to know. Because there is a lack of shuffling for a regular non-object array, there is a cumbersome conversion between Integer objects and an ArrayList and then back to regular ints.

public static int[] getCollectionsShuffledDeck() {
  int[] cards = new int[52];
  ArrayList<Integer> cards_objs = new ArrayList<Integer>(); 
  
  for (int i=0; i < cards.length; i++) {
     cards_objs.add(i);
  }

  Collections.shuffle(cards_objs);
  
  for (int i = 0; i < cards.length; i++) {
    cards[i] = cards_objs.get(i);
  }
  
  return cards;
  
}

With those three methods, I ran a test with each. I ran one million iterations of randomizing fresh decks of cards. I recorded each position (position 0 to 51) and each card in those positions (card 0 to 51, because we don’t actually care which card, just that they’re all uniquely identifiable) and the number of times they appeared in those million trials. So without further ado, look at the astoundingly poor randomness generated by the original algorithm.

The spikes are where there is an obvious failure. I am definitely not a statistician but I can guarantee this is not a great distribution of what is supposed to be random values, especially when the number of trials is so high. With that said, I think it is quite clear that the original method of randomizing a deck of cards is flawed. Now, that’s not to say it is not random, since there is some randomness there, but just not enough. Now, on to the modified method’s chart.

The distribution here is much better. It just so happens that one million divided by 52 is approximately 19230, which is what most of these position-card indexes reach. Clearly, the modified version is better in this case.

The Collections.shuffle random was about the same. This is a great benefit of using the built in routine because you know that this way, it will always be random with that great low variance. That’s not to say there aren’t highs and lows in these two data sets, but it is lesser than the original. I want to be clear though: this may seem at first limited to strictly a card-deck problem but this could present itself anywhere that something starts ordered and needs to be non-ordered after some operation. You may need to randomize your genome project, your particle layout or maybe even your favorite file cabinet.

You can grab the testing program and the excel file for the raw data used to make the charts.

Update: You can read an interesting Stack Overflow question on, “Is Collection.shuffle random enough?“

public static void main(String[] args) {
	int[] arr = new int[] {2804, 2374, 6382, 1899};
	
	int index = 0, largest = arr[0];
	for (int i = 1; i < arr.length; i++) {
		(if largest > arr[i]) {
			index = i;
			largest = arr[i];
		}
	}
}

It’s your typical searching for the largest value loop. It’s nothing special, but then again, it doesn’t work.

At least the error message is logical. No, not really.

the left-hand side of an assignment must be a variable

By studying very carefully and fully realizing that I am still in scheme mode, I notice that there is a parenthesis before the if-statement instead after the if keyword itself. Had I been helping someone else with this code and they showed me that error message along with this, would I have known it was a misplaced parenthesis? No way. I’d eliminate one possibility at a time by removing each successive layer of expressions and assignments until it stopped. I might even go so far as to retype the entire thing. It’s subtle.

It also turns out that if you try to assign a value to a method, you’ll cause this error too.

Happy language switching!

Here’s an example. Look at this code. I dare you even to try running it. You’ll end up with an error.

public static void main(String[] args) {
	int magic = 10;
	if (magic < 20);
	{
		System.out.println("weak magic");
	} 
	else
	{
		System.out.println("strong magic");
	}
}	

The error is of course, uncommunicative of the true problem. Did you spot the error yet?

syntax error on token “else”, delete this token

The problem here isn’t the else or even the if. No, the problem is a semi-colon. Seriously. Take a look at the if-statement expression. The oddity comes about when you actually see the semi-colon attached to the end of it. And because the if-statement ended there, the else has no preceding pair so it has no choice but to error out.

This example is actually a clear cut case of putting a semi-colon after an if-statement expression. Imagine you didn’t have an error to remind you what you just did. You might just have a plain statement and proper following brackets.

public static void main(String[] args) {
	int magic = 10;
	if (magic < 20); {
		System.out.println("weak magic");
	}  
}

Without the else to throw an error message up, how easy would this be to spot? It’s tricky. What if your if-case was a rare edge case condition that you were hard pressed to demonstrate in testing but you theoretically knew it existed? You’d almost never know this wasn’t work until your nuclear reactor began to melt down.

The moral of story: kids will do what you tell them and mind you semi-colons at the end of constructs.

Duplicate local variable

Unfortunately, I didn’t grab his erring source code earlier, so I can’t give the true real world source. Nevertheless, my own crafted code should illuminate the problem sufficiently.

public static void main(String[] args) {
	
	int magic = 10;
	if ( 10 < 11 ) {
		int magic = 12;
		magic++;
	}
	
}

Imagine you had a variable declaration and initialization at the top of some method. Then later you attempt to create another variable with the same name as before, but inside of a construct like a for loop or if. Unwittingly, you have attempted to redeclare an already declared variable.

Why doesn’t the IDE or compiler know that it’s a syntax error in that case, and that you obviously cannot redeclare variables? Java’s just funny like that, but I suspect it has something to do with the scoping rules in Java. The magic variable inside of the if-statement should be separate, and it is telling you it’s a duplicate, not that it isn’t allowed. So I suppose that’s helpful.

In short, the easy fix is to rename the inner-conflicting variable. So the magic that’s in the if-statement could be magic2 and anything that references it in the if should also be updated. That’s clear enough. The other possibility is to remove the int declaration. Imagine you were simply setting value instead of declaring. It’s an easy mistake to make, especially when you’ve a bunch of declarations repeated.

Happy deduplicating!

Years later, I thought it would be cool to redo that program and it certainly was fun. I used the same methodology in fact, but with a couple of optimizations.

I start the program off by creating a Scanner object for user input and a prompt.

Scanner scanner = new Scanner(System.in);
System.out.println("Enter some amount in cents: ");
int cents = scanner.nextInt();

Then the optimizations kick in. There is a denominations array, which has a list of coin values, from 1 dollar, a quarter, a dime, a nickel and finally a penny.

int[] denominations = { 100, 25, 10, 5, 1 };

One of the original requirements of the program was that the amount of coins needed must be in their proper plurality. I can do this easily by having a two dimensional array of strings that store both forms of each word. You might ask, why not just attach an extra s to the end if it’s plural? Well, penny doesn’t turn into pennys.

String[][] terms = { { "dollar", "dollars" },
        { "quarter", "quarters" }, { "dime", "dimes" },
        { "nickle", "nickles" }, { "penny", "pennies" } };

The program will spit out values for each of the denominations listed, so it will contains dollars, quarters and so on and it’s store in this values array.

int[] values = new int[denominations.length];

I use a rolling total to keep track of how much change is left over still.

int rolling = cents;

The magic happens in the for-loop. It’s completely standard, initialized to 0, counting towards the length of the denominations array and incrementing by 1.

for (int i = 0; i < denominations.length; i++) {

The calculations happen in the next section. Basically, the denomination integer pulls the proper value from the denominations array. Then, the value in the values array is set to the integer division of the rolling total and current denomination. Finally, the rolling value is truncated by the denomination by modulus.

    int denomination = denominations[i];
    values[i] = (rolling / denomination);
    rolling = rolling % denomination;

To pick the proper singular or plural, the value is checked against being 1. Keep in mind that values of fractions are indeed plural. You have .1 dollars, e.g. ten cents, or a dime.

    String term = (values[i] == 1 ? terms[i][0] : terms[i][1]);

Finally, there is the printing logic which always gets in the way. I certainly wish there was a better way, but this was the best I found. Basically, by counting up until the last value, I print without a new line the value and then the matching proper term, and when it reaches the last value, I print an and, value, term and finally a period.

    if (i < (denominations.length - 1)) {
        System.out.print(values[i] + " " + term + " ");
    } else {
        System.out.println("and " + values[i] + " " + term);
    }

Here’s a short sample run with different amounts of cents.

Ryans-MacBook-Air:APCS3 ryanrampersad$ java CorrectChange
Enter some amount in cents: 
119
Your change is: 1 dollar 0 quarters 1 dime 1 nickle and 4 pennies.
Ryans-MacBook-Air:APCS3 ryanrampersad$ java CorrectChange
Enter some amount in cents: 
169
Your change is: 1 dollar 2 quarters 1 dime 1 nickle and 4 pennies.
Ryans-MacBook-Air:APCS3 ryanrampersad$ 

I remember when I wrote this program four years ago. This program is 35 lives with a bunch of whitespace. My code from youth was probably more like 70 lines. As you code, you mature. As you read others’ code, you mature too. Experimenting is the best way to grow. You can of course download the full source code.

Happy counting.

I have an array of bytes which comprise my data, then I have an OutputStream with an attached data container file created by a FileOutputStream. All it takes after that is a .write with the data array and finally a .close to close the file stream.

public static void main(String[] args) throws Exception {
 byte[] data = {-1, 0, 0, 1, -1, 0, 1, 1, 1, 0, -1, -1};
 OutputStream out = new FileOutputStream("test.txt");
 out.write(bytes);
 out.close();
}

There are a couple things to keep in mind though. Since this uses the file system, this will may throw exceptions which means you need to catch them. I used throws Exception but you may want to use a try/catch series.

Anyway, printing out a multiplication table like this one isn’t too hard.

x	1	2	3	4	5	
1	1	2	3	4	5	
2	2	4	6	8	10	
3	3	6	9	12	15	
4	4	8	12	16	20	
5	5	10	15	20	25	

Let’s think of the logic behind this. In the first row, we have the X value, so it counts from 1 up to X_max. In the first column, we have the Y value, so it counts from 1 up to Y_max. It is duly noted that the table only has a X listed, but that’s for simplicity, though there is a X and a Y, horizontal and vertical.

In the next row, where X is 1 and Y is 1, we have simple multiplication, 1 times 1, so the value is 1. In the second row and column we have the same numbers as the first row and column because of that by 1 multiplication. Now, we’ll take a look at some code.

public static String getNumber(int i, int j) {
	int value = i * j;
	
	if ( i == 0 ) {
		value = (i+1) * j;
	} else if ( j == 0 ) {
		value = i * (j+1);
	}
	
	if ( i == 0 && j == 0 ) return "x";
	else return value+"";
}

So let’s break this down. You have a value which is obvious in its purpose: it’s the resultant multiplication of some row and some column. Then things get complicated. Since we’re, what? Either computer scientists or insane, we count from zero. Counting from zero makes us think about out logic.

If you’re in the first row, you’ll need to print out what would be the next row. What? Imagine you’re making a table for 5 by 5. You’ll need 1 2 3 4 5. How do you get that? You multiply the column value by 1. But you only want this to happen naturally in the first row (which is actually the zeroth row by our zero-count). And we’ll need the same for the columns going down. So that’s what happens in that first if-else-if stack. If i or j is 0, then it will be temporarily incremented by 1 and it’ll print out the proper rows.

The the if-else stack at the end of this statement is pretty easy too. The if-statement checks to see if i == 0 && j == 0, or if i and j are equal to zero, it will return the X that is the first value in the table. If that condition isn’t true, then it’ll print out either the regular i * j value or the specialized first row/column value.

Now we’ll need a loop.

	for (int i = 0; i <= height; i++) {
		for (int j = 0; j <= width; j++) {
			System.out.print( getNumber(i, j) + "\t" );
		}
		System.out.println("");
	}

This is a nested for-loop. The outside loop will handle the rows (e.g. the height) and the inner loop will handle the columns (e.g. the width). There is a method call to the getNumber with arguments i and j, and a printout that has getNumber and appends a tab character at the end. Finally, in the outside loop, when the inner loop is done running, a newline is printed so that the next row will begin to form.

The logic for this type of program is an exercise in looping and conditional logic with index values. You can grab the source code here.

Happy multiplying.

You’ll need an array full of numbers, those could be integers, doubles, longs, whatever, as long as it is comprised of a number. My solution uses two data keeping variables, largest and index. The largest variable will keep track of the biggest value in the array while the index variable keeps track of where the largest value was found.

Optionally, I like to set the largest and index variables before I start any testing. largest is set to array[0] and index is set to 0 so that we can skip that initial value.

int[] array = {29, 42, 1, 32, 44, 49, 0, 13, 43, 30};
int largest = array[0], index = 0;
for (int i = 1; i < array.length; i++) {
  if ( array[i] > largest ) {
      largest = array[i];
      index = i;
   }
}

This will set index to 5 because 49 is the largest in the array.

If there had been two instances of 49 in the array, which would have been returned? The first one as the code stands. To change it, one would simply have to change the conditional from greater than to equals or greater than.

int[] array = {29, 42, 1, 32, 44, 49, 0, 13, 43, 49};
int largest = array[0], index = 0;
for (int i = 1; i < array.length; i++) {
  if ( array[i] >= largest ) {
      largest = array[i];
      index = i;
   }
}

This would set index to 9 because 49 is the last largest in the array.

Wouldn’t it be nice of Java had a method that did this for you? Like: Arrays.largest or Arrays.smallest which would work for primitive numeric values. Simple and obvious.

Happy indexing.

So you relent and you take it upon yourself to be diligent and actually update Java, you tell UAC it’s fine and to proceed. And then the Java installer comes up asking you to accept some terms of service before the update is downloaded and installed. But then. This.

Now what? What can you do? The little Java icon in the task tray is gone and it won’t pop up again for a few hours. There is no solution to this problem, except for downloading the new version of Java directly. Or you can wait again until the prompt comes back up. That’ll work too.

I had a special case – needing both the key and the value at the same time. Let’s go with one or the other for right now. Let’s establish our map.

HashMap<String, String> map = new HashMap<String, String>();
map.add("Hello", "world");
map.add("Ryan", "rampersad");

That’s our example map. It doesn’t really matter what the contents are, but it’s example.

Now, let’s loop over the keys.

Iterator it = map.keySet().iterator();
while (it.hasNext()) System.out.println( it.next() );

This will print out Hello and Ryan. Those are the keys of the values in the Hash Map.

Now let’s loop over the values.

Iterator it = map.values().iterator();
while (it.hasNext()) System.out.println( it.next() );

This will print out world and rampersad. Those are the values.

Finally, the most interesting. To get the value and the key at the same time, a special Map Entry object can be made with an entry set.

Iterator it = map.entrySet().iterator();
while (it.hasNext()) {
  Map.Entry<String, String> kv = it.next();
  System.out.println(kv.getKey() + "=" + kv.getValue());
}

This code prints Hello=world and Ryan=rampersad.
This is new. First, we call entrySet to get the special set of key-value pairs. Then in the loop itself we use a special Map.Entry object with parameters of String, String, because that’s how our map is made, and set it to it.next. That enables use to call for the key and the value.

I hate while loops so I suggest this format instead.

for (Map.Entry<String, String> kv: map.entrySet()) {
  System.out.println(kv.getKey() + "=" + kv.getValue());
}

The beauty of this is that there is no Map.Entry object being declared inside the actual loop, instead it’s made it its header. All the cleaner.

Getting a key-value pair from a HashMap, the point of HashMap, I think, is slightly convoluted but nothing hard.

Happy mapping.